186470930SIngo Molnar /* 286470930SIngo Molnar * builtin-stat.c 386470930SIngo Molnar * 486470930SIngo Molnar * Builtin stat command: Give a precise performance counters summary 586470930SIngo Molnar * overview about any workload, CPU or specific PID. 686470930SIngo Molnar * 786470930SIngo Molnar * Sample output: 886470930SIngo Molnar 92cba3ffbSIngo Molnar $ perf stat ./hackbench 10 1086470930SIngo Molnar 112cba3ffbSIngo Molnar Time: 0.118 1286470930SIngo Molnar 132cba3ffbSIngo Molnar Performance counter stats for './hackbench 10': 1486470930SIngo Molnar 152cba3ffbSIngo Molnar 1708.761321 task-clock # 11.037 CPUs utilized 162cba3ffbSIngo Molnar 41,190 context-switches # 0.024 M/sec 172cba3ffbSIngo Molnar 6,735 CPU-migrations # 0.004 M/sec 182cba3ffbSIngo Molnar 17,318 page-faults # 0.010 M/sec 192cba3ffbSIngo Molnar 5,205,202,243 cycles # 3.046 GHz 202cba3ffbSIngo Molnar 3,856,436,920 stalled-cycles-frontend # 74.09% frontend cycles idle 212cba3ffbSIngo Molnar 1,600,790,871 stalled-cycles-backend # 30.75% backend cycles idle 222cba3ffbSIngo Molnar 2,603,501,247 instructions # 0.50 insns per cycle 232cba3ffbSIngo Molnar # 1.48 stalled cycles per insn 242cba3ffbSIngo Molnar 484,357,498 branches # 283.455 M/sec 252cba3ffbSIngo Molnar 6,388,934 branch-misses # 1.32% of all branches 262cba3ffbSIngo Molnar 272cba3ffbSIngo Molnar 0.154822978 seconds time elapsed 2886470930SIngo Molnar 2986470930SIngo Molnar * 302cba3ffbSIngo Molnar * Copyright (C) 2008-2011, Red Hat Inc, Ingo Molnar <mingo@redhat.com> 3186470930SIngo Molnar * 3286470930SIngo Molnar * Improvements and fixes by: 3386470930SIngo Molnar * 3486470930SIngo Molnar * Arjan van de Ven <arjan@linux.intel.com> 3586470930SIngo Molnar * Yanmin Zhang <yanmin.zhang@intel.com> 3686470930SIngo Molnar * Wu Fengguang <fengguang.wu@intel.com> 3786470930SIngo Molnar * Mike Galbraith <efault@gmx.de> 3886470930SIngo Molnar * Paul Mackerras <paulus@samba.org> 396e750a8fSJaswinder Singh Rajput * Jaswinder Singh Rajput <jaswinder@kernel.org> 4086470930SIngo Molnar * 4186470930SIngo Molnar * Released under the GPL v2. (and only v2, not any later version) 4286470930SIngo Molnar */ 4386470930SIngo Molnar 4486470930SIngo Molnar #include "perf.h" 4586470930SIngo Molnar #include "builtin.h" 46f14d5707SArnaldo Carvalho de Melo #include "util/cgroup.h" 4786470930SIngo Molnar #include "util/util.h" 484b6ab94eSJosh Poimboeuf #include <subcmd/parse-options.h> 4986470930SIngo Molnar #include "util/parse-events.h" 504cabc3d1SAndi Kleen #include "util/pmu.h" 518f28827aSFrederic Weisbecker #include "util/event.h" 52361c99a6SArnaldo Carvalho de Melo #include "util/evlist.h" 5369aad6f1SArnaldo Carvalho de Melo #include "util/evsel.h" 548f28827aSFrederic Weisbecker #include "util/debug.h" 555d8bb1ecSMathieu Poirier #include "util/drv_configs.h" 56a5d243d0SIngo Molnar #include "util/color.h" 570007eceaSXiao Guangrong #include "util/stat.h" 5860666c63SLiming Wang #include "util/header.h" 59a12b51c4SPaul Mackerras #include "util/cpumap.h" 60d6d901c2SZhang, Yanmin #include "util/thread.h" 61fd78260bSArnaldo Carvalho de Melo #include "util/thread_map.h" 62d809560bSJiri Olsa #include "util/counts.h" 6344b1e60aSAndi Kleen #include "util/group.h" 644979d0c7SJiri Olsa #include "util/session.h" 65ba6039b6SJiri Olsa #include "util/tool.h" 6644b1e60aSAndi Kleen #include "util/group.h" 67ba6039b6SJiri Olsa #include "asm/bug.h" 6886470930SIngo Molnar 69bd48c63eSArnaldo Carvalho de Melo #include <linux/time64.h> 7044b1e60aSAndi Kleen #include <api/fs/fs.h> 711f16c575SPeter Zijlstra #include <stdlib.h> 7286470930SIngo Molnar #include <sys/prctl.h> 735af52b51SStephane Eranian #include <locale.h> 74e3b03b6cSAndi Kleen #include <math.h> 7586470930SIngo Molnar 76d7470b6aSStephane Eranian #define DEFAULT_SEPARATOR " " 772cee77c4SDavid Ahern #define CNTR_NOT_SUPPORTED "<not supported>" 782cee77c4SDavid Ahern #define CNTR_NOT_COUNTED "<not counted>" 79d7470b6aSStephane Eranian 80d4f63a47SJiri Olsa static void print_counters(struct timespec *ts, int argc, const char **argv); 8113370a9bSStephane Eranian 824cabc3d1SAndi Kleen /* Default events used for perf stat -T */ 83a454742cSJiri Olsa static const char *transaction_attrs = { 84a454742cSJiri Olsa "task-clock," 854cabc3d1SAndi Kleen "{" 864cabc3d1SAndi Kleen "instructions," 874cabc3d1SAndi Kleen "cycles," 884cabc3d1SAndi Kleen "cpu/cycles-t/," 894cabc3d1SAndi Kleen "cpu/tx-start/," 904cabc3d1SAndi Kleen "cpu/el-start/," 914cabc3d1SAndi Kleen "cpu/cycles-ct/" 924cabc3d1SAndi Kleen "}" 934cabc3d1SAndi Kleen }; 944cabc3d1SAndi Kleen 954cabc3d1SAndi Kleen /* More limited version when the CPU does not have all events. */ 96a454742cSJiri Olsa static const char * transaction_limited_attrs = { 97a454742cSJiri Olsa "task-clock," 984cabc3d1SAndi Kleen "{" 994cabc3d1SAndi Kleen "instructions," 1004cabc3d1SAndi Kleen "cycles," 1014cabc3d1SAndi Kleen "cpu/cycles-t/," 1024cabc3d1SAndi Kleen "cpu/tx-start/" 1034cabc3d1SAndi Kleen "}" 1044cabc3d1SAndi Kleen }; 1054cabc3d1SAndi Kleen 10644b1e60aSAndi Kleen static const char * topdown_attrs[] = { 10744b1e60aSAndi Kleen "topdown-total-slots", 10844b1e60aSAndi Kleen "topdown-slots-retired", 10944b1e60aSAndi Kleen "topdown-recovery-bubbles", 11044b1e60aSAndi Kleen "topdown-fetch-bubbles", 11144b1e60aSAndi Kleen "topdown-slots-issued", 11244b1e60aSAndi Kleen NULL, 11344b1e60aSAndi Kleen }; 11444b1e60aSAndi Kleen 115666e6d48SRobert Richter static struct perf_evlist *evsel_list; 116361c99a6SArnaldo Carvalho de Melo 117602ad878SArnaldo Carvalho de Melo static struct target target = { 11877a6f014SNamhyung Kim .uid = UINT_MAX, 11977a6f014SNamhyung Kim }; 12042202dd5SIngo Molnar 1211e5a2931SJiri Olsa typedef int (*aggr_get_id_t)(struct cpu_map *m, int cpu); 1221e5a2931SJiri Olsa 1233d632595SJaswinder Singh Rajput static int run_count = 1; 1242e6cdf99SStephane Eranian static bool no_inherit = false; 125d07f0b12SStephane Eranian static volatile pid_t child_pid = -1; 126c0555642SIan Munsie static bool null_run = false; 1272cba3ffbSIngo Molnar static int detailed_run = 0; 1284cabc3d1SAndi Kleen static bool transaction_run; 12944b1e60aSAndi Kleen static bool topdown_run = false; 130201e0b06SArnaldo Carvalho de Melo static bool big_num = true; 131d7470b6aSStephane Eranian static int big_num_opt = -1; 132d7470b6aSStephane Eranian static const char *csv_sep = NULL; 133d7470b6aSStephane Eranian static bool csv_output = false; 13443bece79SLin Ming static bool group = false; 1351f16c575SPeter Zijlstra static const char *pre_cmd = NULL; 1361f16c575SPeter Zijlstra static const char *post_cmd = NULL; 1371f16c575SPeter Zijlstra static bool sync_run = false; 13841191688SAndi Kleen static unsigned int initial_delay = 0; 139410136f5SStephane Eranian static unsigned int unit_width = 4; /* strlen("unit") */ 140a7e191c3SFrederik Deweerdt static bool forever = false; 14154b50916SAndi Kleen static bool metric_only = false; 14244b1e60aSAndi Kleen static bool force_metric_only = false; 143430daf2dSAndi Kleen static bool no_merge = false; 14413370a9bSStephane Eranian static struct timespec ref_time; 14586ee6e18SStephane Eranian static struct cpu_map *aggr_map; 1461e5a2931SJiri Olsa static aggr_get_id_t aggr_get_id; 147e0547311SJiri Olsa static bool append_file; 148e0547311SJiri Olsa static const char *output_name; 149e0547311SJiri Olsa static int output_fd; 15002d492e5SBorislav Petkov static int print_free_counters_hint; 1515af52b51SStephane Eranian 1524979d0c7SJiri Olsa struct perf_stat { 1534979d0c7SJiri Olsa bool record; 1544979d0c7SJiri Olsa struct perf_data_file file; 1554979d0c7SJiri Olsa struct perf_session *session; 1564979d0c7SJiri Olsa u64 bytes_written; 157ba6039b6SJiri Olsa struct perf_tool tool; 1581975d36eSJiri Olsa bool maps_allocated; 1591975d36eSJiri Olsa struct cpu_map *cpus; 1601975d36eSJiri Olsa struct thread_map *threads; 16189af4e05SJiri Olsa enum aggr_mode aggr_mode; 1624979d0c7SJiri Olsa }; 1634979d0c7SJiri Olsa 1644979d0c7SJiri Olsa static struct perf_stat perf_stat; 1654979d0c7SJiri Olsa #define STAT_RECORD perf_stat.record 1664979d0c7SJiri Olsa 16760666c63SLiming Wang static volatile int done = 0; 16860666c63SLiming Wang 169421a50f3SJiri Olsa static struct perf_stat_config stat_config = { 170421a50f3SJiri Olsa .aggr_mode = AGGR_GLOBAL, 171711a572eSJiri Olsa .scale = true, 172421a50f3SJiri Olsa }; 173421a50f3SJiri Olsa 17413370a9bSStephane Eranian static inline void diff_timespec(struct timespec *r, struct timespec *a, 17513370a9bSStephane Eranian struct timespec *b) 17613370a9bSStephane Eranian { 17713370a9bSStephane Eranian r->tv_sec = a->tv_sec - b->tv_sec; 17813370a9bSStephane Eranian if (a->tv_nsec < b->tv_nsec) { 179310ebb93SArnaldo Carvalho de Melo r->tv_nsec = a->tv_nsec + NSEC_PER_SEC - b->tv_nsec; 18013370a9bSStephane Eranian r->tv_sec--; 18113370a9bSStephane Eranian } else { 18213370a9bSStephane Eranian r->tv_nsec = a->tv_nsec - b->tv_nsec ; 18313370a9bSStephane Eranian } 18413370a9bSStephane Eranian } 18513370a9bSStephane Eranian 186254ecbc7SJiri Olsa static void perf_stat__reset_stats(void) 187254ecbc7SJiri Olsa { 188254ecbc7SJiri Olsa perf_evlist__reset_stats(evsel_list); 189f87027b9SJiri Olsa perf_stat__reset_shadow_stats(); 1901eda3b21SJiri Olsa } 1911eda3b21SJiri Olsa 192cac21425SJiri Olsa static int create_perf_stat_counter(struct perf_evsel *evsel) 19386470930SIngo Molnar { 19469aad6f1SArnaldo Carvalho de Melo struct perf_event_attr *attr = &evsel->attr; 195727ab04eSArnaldo Carvalho de Melo 196711a572eSJiri Olsa if (stat_config.scale) 19786470930SIngo Molnar attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | 19886470930SIngo Molnar PERF_FORMAT_TOTAL_TIME_RUNNING; 19986470930SIngo Molnar 2002e6cdf99SStephane Eranian attr->inherit = !no_inherit; 2015d2cd909SArnaldo Carvalho de Melo 2026acd8e92SJiri Olsa /* 2036acd8e92SJiri Olsa * Some events get initialized with sample_(period/type) set, 2046acd8e92SJiri Olsa * like tracepoints. Clear it up for counting. 2056acd8e92SJiri Olsa */ 2066acd8e92SJiri Olsa attr->sample_period = 0; 2076db1a5c1SJiri Olsa 2084979d0c7SJiri Olsa /* 2094979d0c7SJiri Olsa * But set sample_type to PERF_SAMPLE_IDENTIFIER, which should be harmless 2104979d0c7SJiri Olsa * while avoiding that older tools show confusing messages. 2116db1a5c1SJiri Olsa * 2126db1a5c1SJiri Olsa * However for pipe sessions we need to keep it zero, 2136db1a5c1SJiri Olsa * because script's perf_evsel__check_attr is triggered 2146db1a5c1SJiri Olsa * by attr->sample_type != 0, and we can't run it on 2156db1a5c1SJiri Olsa * stat sessions. 2164979d0c7SJiri Olsa */ 2176db1a5c1SJiri Olsa if (!(STAT_RECORD && perf_stat.file.is_pipe)) 2184979d0c7SJiri Olsa attr->sample_type = PERF_SAMPLE_IDENTIFIER; 2196acd8e92SJiri Olsa 22067ccdecdSJiri Olsa /* 22167ccdecdSJiri Olsa * Disabling all counters initially, they will be enabled 22267ccdecdSJiri Olsa * either manually by us or by kernel via enable_on_exec 22367ccdecdSJiri Olsa * set later. 22467ccdecdSJiri Olsa */ 225c8280cecSJiri Olsa if (perf_evsel__is_group_leader(evsel)) { 22667ccdecdSJiri Olsa attr->disabled = 1; 22767ccdecdSJiri Olsa 228c8280cecSJiri Olsa /* 229c8280cecSJiri Olsa * In case of initial_delay we enable tracee 230c8280cecSJiri Olsa * events manually. 231c8280cecSJiri Olsa */ 232c8280cecSJiri Olsa if (target__none(&target) && !initial_delay) 233c8280cecSJiri Olsa attr->enable_on_exec = 1; 234c8280cecSJiri Olsa } 235c8280cecSJiri Olsa 236602ad878SArnaldo Carvalho de Melo if (target__has_cpu(&target)) 237594ac61aSArnaldo Carvalho de Melo return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel)); 2385622c07bSStephane Eranian 239594ac61aSArnaldo Carvalho de Melo return perf_evsel__open_per_thread(evsel, evsel_list->threads); 24086470930SIngo Molnar } 24186470930SIngo Molnar 24286470930SIngo Molnar /* 24386470930SIngo Molnar * Does the counter have nsecs as a unit? 24486470930SIngo Molnar */ 245daec78a0SArnaldo Carvalho de Melo static inline int nsec_counter(struct perf_evsel *evsel) 24686470930SIngo Molnar { 247daec78a0SArnaldo Carvalho de Melo if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) || 248daec78a0SArnaldo Carvalho de Melo perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK)) 24986470930SIngo Molnar return 1; 25086470930SIngo Molnar 25186470930SIngo Molnar return 0; 25286470930SIngo Molnar } 25386470930SIngo Molnar 2548b99b1a4SJiri Olsa static int process_synthesized_event(struct perf_tool *tool __maybe_unused, 2554979d0c7SJiri Olsa union perf_event *event, 2564979d0c7SJiri Olsa struct perf_sample *sample __maybe_unused, 2574979d0c7SJiri Olsa struct machine *machine __maybe_unused) 2584979d0c7SJiri Olsa { 2598b99b1a4SJiri Olsa if (perf_data_file__write(&perf_stat.file, event, event->header.size) < 0) { 2608b99b1a4SJiri Olsa pr_err("failed to write perf data, error: %m\n"); 2618b99b1a4SJiri Olsa return -1; 2628b99b1a4SJiri Olsa } 2638b99b1a4SJiri Olsa 2648b99b1a4SJiri Olsa perf_stat.bytes_written += event->header.size; 2658b99b1a4SJiri Olsa return 0; 2664979d0c7SJiri Olsa } 2674979d0c7SJiri Olsa 2681975d36eSJiri Olsa static int write_stat_round_event(u64 tm, u64 type) 2697aad0c32SJiri Olsa { 2701975d36eSJiri Olsa return perf_event__synthesize_stat_round(NULL, tm, type, 2717aad0c32SJiri Olsa process_synthesized_event, 2727aad0c32SJiri Olsa NULL); 2737aad0c32SJiri Olsa } 2747aad0c32SJiri Olsa 2757aad0c32SJiri Olsa #define WRITE_STAT_ROUND_EVENT(time, interval) \ 2767aad0c32SJiri Olsa write_stat_round_event(time, PERF_STAT_ROUND_TYPE__ ## interval) 2777aad0c32SJiri Olsa 2785a6ea81bSJiri Olsa #define SID(e, x, y) xyarray__entry(e->sample_id, x, y) 2795a6ea81bSJiri Olsa 2805a6ea81bSJiri Olsa static int 2815a6ea81bSJiri Olsa perf_evsel__write_stat_event(struct perf_evsel *counter, u32 cpu, u32 thread, 2825a6ea81bSJiri Olsa struct perf_counts_values *count) 2835a6ea81bSJiri Olsa { 2845a6ea81bSJiri Olsa struct perf_sample_id *sid = SID(counter, cpu, thread); 2855a6ea81bSJiri Olsa 2865a6ea81bSJiri Olsa return perf_event__synthesize_stat(NULL, cpu, thread, sid->id, count, 2875a6ea81bSJiri Olsa process_synthesized_event, NULL); 2885a6ea81bSJiri Olsa } 2895a6ea81bSJiri Olsa 290f5b4a9c3SStephane Eranian /* 291f5b4a9c3SStephane Eranian * Read out the results of a single counter: 292f5b4a9c3SStephane Eranian * do not aggregate counts across CPUs in system-wide mode 293f5b4a9c3SStephane Eranian */ 294c52b12edSArnaldo Carvalho de Melo static int read_counter(struct perf_evsel *counter) 295f5b4a9c3SStephane Eranian { 2969bf1a529SJiri Olsa int nthreads = thread_map__nr(evsel_list->threads); 29700e727bbSMark Rutland int ncpus, cpu, thread; 29800e727bbSMark Rutland 29900e727bbSMark Rutland if (target__has_cpu(&target)) 30000e727bbSMark Rutland ncpus = perf_evsel__nr_cpus(counter); 30100e727bbSMark Rutland else 30200e727bbSMark Rutland ncpus = 1; 303f5b4a9c3SStephane Eranian 3043b4331d9SSuzuki K. Poulose if (!counter->supported) 3053b4331d9SSuzuki K. Poulose return -ENOENT; 3063b4331d9SSuzuki K. Poulose 3079bf1a529SJiri Olsa if (counter->system_wide) 3089bf1a529SJiri Olsa nthreads = 1; 3099bf1a529SJiri Olsa 3109bf1a529SJiri Olsa for (thread = 0; thread < nthreads; thread++) { 3119bf1a529SJiri Olsa for (cpu = 0; cpu < ncpus; cpu++) { 3123b3eb044SJiri Olsa struct perf_counts_values *count; 3133b3eb044SJiri Olsa 3143b3eb044SJiri Olsa count = perf_counts(counter->counts, cpu, thread); 315db49a717SStephane Eranian if (perf_evsel__read(counter, cpu, thread, count)) { 316db49a717SStephane Eranian counter->counts->scaled = -1; 317db49a717SStephane Eranian perf_counts(counter->counts, cpu, thread)->ena = 0; 318db49a717SStephane Eranian perf_counts(counter->counts, cpu, thread)->run = 0; 319c52b12edSArnaldo Carvalho de Melo return -1; 320db49a717SStephane Eranian } 3215a6ea81bSJiri Olsa 3225a6ea81bSJiri Olsa if (STAT_RECORD) { 3235a6ea81bSJiri Olsa if (perf_evsel__write_stat_event(counter, cpu, thread, count)) { 3245a6ea81bSJiri Olsa pr_err("failed to write stat event\n"); 3255a6ea81bSJiri Olsa return -1; 3265a6ea81bSJiri Olsa } 3275a6ea81bSJiri Olsa } 3280b1abbf4SAndi Kleen 3290b1abbf4SAndi Kleen if (verbose > 1) { 3300b1abbf4SAndi Kleen fprintf(stat_config.output, 3310b1abbf4SAndi Kleen "%s: %d: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n", 3320b1abbf4SAndi Kleen perf_evsel__name(counter), 3330b1abbf4SAndi Kleen cpu, 3340b1abbf4SAndi Kleen count->val, count->ena, count->run); 3350b1abbf4SAndi Kleen } 336f5b4a9c3SStephane Eranian } 3379bf1a529SJiri Olsa } 338c52b12edSArnaldo Carvalho de Melo 339c52b12edSArnaldo Carvalho de Melo return 0; 34086470930SIngo Molnar } 34186470930SIngo Molnar 3423df33effSMark Rutland static void read_counters(void) 343106a94a0SJiri Olsa { 344106a94a0SJiri Olsa struct perf_evsel *counter; 345db49a717SStephane Eranian int ret; 346106a94a0SJiri Olsa 347e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 348db49a717SStephane Eranian ret = read_counter(counter); 349db49a717SStephane Eranian if (ret) 350245bad8eSAndi Kleen pr_debug("failed to read counter %s\n", counter->name); 3513b3eb044SJiri Olsa 352db49a717SStephane Eranian if (ret == 0 && perf_stat_process_counter(&stat_config, counter)) 3533b3eb044SJiri Olsa pr_warning("failed to process counter %s\n", counter->name); 354106a94a0SJiri Olsa } 355106a94a0SJiri Olsa } 356106a94a0SJiri Olsa 357ba411a95SJiri Olsa static void process_interval(void) 35813370a9bSStephane Eranian { 35913370a9bSStephane Eranian struct timespec ts, rs; 36013370a9bSStephane Eranian 3613df33effSMark Rutland read_counters(); 36286ee6e18SStephane Eranian 36313370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ts); 36413370a9bSStephane Eranian diff_timespec(&rs, &ts, &ref_time); 36513370a9bSStephane Eranian 3667aad0c32SJiri Olsa if (STAT_RECORD) { 367bd48c63eSArnaldo Carvalho de Melo if (WRITE_STAT_ROUND_EVENT(rs.tv_sec * NSEC_PER_SEC + rs.tv_nsec, INTERVAL)) 3687aad0c32SJiri Olsa pr_err("failed to write stat round event\n"); 3697aad0c32SJiri Olsa } 3707aad0c32SJiri Olsa 371d4f63a47SJiri Olsa print_counters(&rs, 0, NULL); 37213370a9bSStephane Eranian } 37313370a9bSStephane Eranian 37467ccdecdSJiri Olsa static void enable_counters(void) 37541191688SAndi Kleen { 37667ccdecdSJiri Olsa if (initial_delay) 377310ebb93SArnaldo Carvalho de Melo usleep(initial_delay * USEC_PER_MSEC); 37867ccdecdSJiri Olsa 37967ccdecdSJiri Olsa /* 38067ccdecdSJiri Olsa * We need to enable counters only if: 38167ccdecdSJiri Olsa * - we don't have tracee (attaching to task or cpu) 38267ccdecdSJiri Olsa * - we have initial delay configured 38367ccdecdSJiri Olsa */ 38467ccdecdSJiri Olsa if (!target__none(&target) || initial_delay) 385ab46db0aSJiri Olsa perf_evlist__enable(evsel_list); 38641191688SAndi Kleen } 38741191688SAndi Kleen 3883df33effSMark Rutland static void disable_counters(void) 3893df33effSMark Rutland { 3903df33effSMark Rutland /* 3913df33effSMark Rutland * If we don't have tracee (attaching to task or cpu), counters may 3923df33effSMark Rutland * still be running. To get accurate group ratios, we must stop groups 3933df33effSMark Rutland * from counting before reading their constituent counters. 3943df33effSMark Rutland */ 3953df33effSMark Rutland if (!target__none(&target)) 3963df33effSMark Rutland perf_evlist__disable(evsel_list); 3973df33effSMark Rutland } 3983df33effSMark Rutland 399f33cbe72SArnaldo Carvalho de Melo static volatile int workload_exec_errno; 4006af206fdSArnaldo Carvalho de Melo 4016af206fdSArnaldo Carvalho de Melo /* 4026af206fdSArnaldo Carvalho de Melo * perf_evlist__prepare_workload will send a SIGUSR1 4036af206fdSArnaldo Carvalho de Melo * if the fork fails, since we asked by setting its 4046af206fdSArnaldo Carvalho de Melo * want_signal to true. 4056af206fdSArnaldo Carvalho de Melo */ 406f33cbe72SArnaldo Carvalho de Melo static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info, 407f33cbe72SArnaldo Carvalho de Melo void *ucontext __maybe_unused) 4086af206fdSArnaldo Carvalho de Melo { 409f33cbe72SArnaldo Carvalho de Melo workload_exec_errno = info->si_value.sival_int; 4106af206fdSArnaldo Carvalho de Melo } 4116af206fdSArnaldo Carvalho de Melo 4127b60a7e3SJiri Olsa static bool has_unit(struct perf_evsel *counter) 4137b60a7e3SJiri Olsa { 4147b60a7e3SJiri Olsa return counter->unit && *counter->unit; 4157b60a7e3SJiri Olsa } 4167b60a7e3SJiri Olsa 4177b60a7e3SJiri Olsa static bool has_scale(struct perf_evsel *counter) 4187b60a7e3SJiri Olsa { 4197b60a7e3SJiri Olsa return counter->scale != 1; 4207b60a7e3SJiri Olsa } 4217b60a7e3SJiri Olsa 422664c98d4SJiri Olsa static int perf_stat_synthesize_config(bool is_pipe) 4238b99b1a4SJiri Olsa { 4247b60a7e3SJiri Olsa struct perf_evsel *counter; 4258b99b1a4SJiri Olsa int err; 4268b99b1a4SJiri Olsa 427664c98d4SJiri Olsa if (is_pipe) { 428664c98d4SJiri Olsa err = perf_event__synthesize_attrs(NULL, perf_stat.session, 429664c98d4SJiri Olsa process_synthesized_event); 430664c98d4SJiri Olsa if (err < 0) { 431664c98d4SJiri Olsa pr_err("Couldn't synthesize attrs.\n"); 432664c98d4SJiri Olsa return err; 433664c98d4SJiri Olsa } 434664c98d4SJiri Olsa } 435664c98d4SJiri Olsa 4367b60a7e3SJiri Olsa /* 4377b60a7e3SJiri Olsa * Synthesize other events stuff not carried within 4387b60a7e3SJiri Olsa * attr event - unit, scale, name 4397b60a7e3SJiri Olsa */ 440e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 4417b60a7e3SJiri Olsa if (!counter->supported) 4427b60a7e3SJiri Olsa continue; 4437b60a7e3SJiri Olsa 4447b60a7e3SJiri Olsa /* 4457b60a7e3SJiri Olsa * Synthesize unit and scale only if it's defined. 4467b60a7e3SJiri Olsa */ 4477b60a7e3SJiri Olsa if (has_unit(counter)) { 4487b60a7e3SJiri Olsa err = perf_event__synthesize_event_update_unit(NULL, counter, process_synthesized_event); 4497b60a7e3SJiri Olsa if (err < 0) { 4507b60a7e3SJiri Olsa pr_err("Couldn't synthesize evsel unit.\n"); 4517b60a7e3SJiri Olsa return err; 4527b60a7e3SJiri Olsa } 4537b60a7e3SJiri Olsa } 4547b60a7e3SJiri Olsa 4557b60a7e3SJiri Olsa if (has_scale(counter)) { 4567b60a7e3SJiri Olsa err = perf_event__synthesize_event_update_scale(NULL, counter, process_synthesized_event); 4577b60a7e3SJiri Olsa if (err < 0) { 4587b60a7e3SJiri Olsa pr_err("Couldn't synthesize evsel scale.\n"); 4597b60a7e3SJiri Olsa return err; 4607b60a7e3SJiri Olsa } 4617b60a7e3SJiri Olsa } 4627b60a7e3SJiri Olsa 4637b60a7e3SJiri Olsa if (counter->own_cpus) { 4647b60a7e3SJiri Olsa err = perf_event__synthesize_event_update_cpus(NULL, counter, process_synthesized_event); 4657b60a7e3SJiri Olsa if (err < 0) { 4667b60a7e3SJiri Olsa pr_err("Couldn't synthesize evsel scale.\n"); 4677b60a7e3SJiri Olsa return err; 4687b60a7e3SJiri Olsa } 4697b60a7e3SJiri Olsa } 4707b60a7e3SJiri Olsa 4717b60a7e3SJiri Olsa /* 4727b60a7e3SJiri Olsa * Name is needed only for pipe output, 4737b60a7e3SJiri Olsa * perf.data carries event names. 4747b60a7e3SJiri Olsa */ 4757b60a7e3SJiri Olsa if (is_pipe) { 4767b60a7e3SJiri Olsa err = perf_event__synthesize_event_update_name(NULL, counter, process_synthesized_event); 4777b60a7e3SJiri Olsa if (err < 0) { 4787b60a7e3SJiri Olsa pr_err("Couldn't synthesize evsel name.\n"); 4797b60a7e3SJiri Olsa return err; 4807b60a7e3SJiri Olsa } 4817b60a7e3SJiri Olsa } 4827b60a7e3SJiri Olsa } 4837b60a7e3SJiri Olsa 4848b99b1a4SJiri Olsa err = perf_event__synthesize_thread_map2(NULL, evsel_list->threads, 4858b99b1a4SJiri Olsa process_synthesized_event, 4868b99b1a4SJiri Olsa NULL); 4878b99b1a4SJiri Olsa if (err < 0) { 4888b99b1a4SJiri Olsa pr_err("Couldn't synthesize thread map.\n"); 4898b99b1a4SJiri Olsa return err; 4908b99b1a4SJiri Olsa } 4918b99b1a4SJiri Olsa 4928b99b1a4SJiri Olsa err = perf_event__synthesize_cpu_map(NULL, evsel_list->cpus, 4938b99b1a4SJiri Olsa process_synthesized_event, NULL); 4948b99b1a4SJiri Olsa if (err < 0) { 4958b99b1a4SJiri Olsa pr_err("Couldn't synthesize thread map.\n"); 4968b99b1a4SJiri Olsa return err; 4978b99b1a4SJiri Olsa } 4988b99b1a4SJiri Olsa 4998b99b1a4SJiri Olsa err = perf_event__synthesize_stat_config(NULL, &stat_config, 5008b99b1a4SJiri Olsa process_synthesized_event, NULL); 5018b99b1a4SJiri Olsa if (err < 0) { 5028b99b1a4SJiri Olsa pr_err("Couldn't synthesize config.\n"); 5038b99b1a4SJiri Olsa return err; 5048b99b1a4SJiri Olsa } 5058b99b1a4SJiri Olsa 5068b99b1a4SJiri Olsa return 0; 5078b99b1a4SJiri Olsa } 5088b99b1a4SJiri Olsa 5092af4646dSJiri Olsa #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y)) 5102af4646dSJiri Olsa 5112af4646dSJiri Olsa static int __store_counter_ids(struct perf_evsel *counter, 5122af4646dSJiri Olsa struct cpu_map *cpus, 5132af4646dSJiri Olsa struct thread_map *threads) 5142af4646dSJiri Olsa { 5152af4646dSJiri Olsa int cpu, thread; 5162af4646dSJiri Olsa 5172af4646dSJiri Olsa for (cpu = 0; cpu < cpus->nr; cpu++) { 5182af4646dSJiri Olsa for (thread = 0; thread < threads->nr; thread++) { 5192af4646dSJiri Olsa int fd = FD(counter, cpu, thread); 5202af4646dSJiri Olsa 5212af4646dSJiri Olsa if (perf_evlist__id_add_fd(evsel_list, counter, 5222af4646dSJiri Olsa cpu, thread, fd) < 0) 5232af4646dSJiri Olsa return -1; 5242af4646dSJiri Olsa } 5252af4646dSJiri Olsa } 5262af4646dSJiri Olsa 5272af4646dSJiri Olsa return 0; 5282af4646dSJiri Olsa } 5292af4646dSJiri Olsa 5302af4646dSJiri Olsa static int store_counter_ids(struct perf_evsel *counter) 5312af4646dSJiri Olsa { 5322af4646dSJiri Olsa struct cpu_map *cpus = counter->cpus; 5332af4646dSJiri Olsa struct thread_map *threads = counter->threads; 5342af4646dSJiri Olsa 5352af4646dSJiri Olsa if (perf_evsel__alloc_id(counter, cpus->nr, threads->nr)) 5362af4646dSJiri Olsa return -ENOMEM; 5372af4646dSJiri Olsa 5382af4646dSJiri Olsa return __store_counter_ids(counter, cpus, threads); 5392af4646dSJiri Olsa } 5402af4646dSJiri Olsa 541acf28922SNamhyung Kim static int __run_perf_stat(int argc, const char **argv) 54286470930SIngo Molnar { 543ec0d3d1fSJiri Olsa int interval = stat_config.interval; 544d6195a6aSArnaldo Carvalho de Melo char msg[BUFSIZ]; 54586470930SIngo Molnar unsigned long long t0, t1; 546cac21425SJiri Olsa struct perf_evsel *counter; 54713370a9bSStephane Eranian struct timespec ts; 548410136f5SStephane Eranian size_t l; 54942202dd5SIngo Molnar int status = 0; 5506be2850eSZhang, Yanmin const bool forks = (argc > 0); 551664c98d4SJiri Olsa bool is_pipe = STAT_RECORD ? perf_stat.file.is_pipe : false; 5525d8bb1ecSMathieu Poirier struct perf_evsel_config_term *err_term; 55386470930SIngo Molnar 55413370a9bSStephane Eranian if (interval) { 555310ebb93SArnaldo Carvalho de Melo ts.tv_sec = interval / USEC_PER_MSEC; 556310ebb93SArnaldo Carvalho de Melo ts.tv_nsec = (interval % USEC_PER_MSEC) * NSEC_PER_MSEC; 55713370a9bSStephane Eranian } else { 55813370a9bSStephane Eranian ts.tv_sec = 1; 55913370a9bSStephane Eranian ts.tv_nsec = 0; 56013370a9bSStephane Eranian } 56113370a9bSStephane Eranian 562acf28922SNamhyung Kim if (forks) { 563664c98d4SJiri Olsa if (perf_evlist__prepare_workload(evsel_list, &target, argv, is_pipe, 564735f7e0bSArnaldo Carvalho de Melo workload_exec_failed_signal) < 0) { 565acf28922SNamhyung Kim perror("failed to prepare workload"); 566fceda7feSDavid Ahern return -1; 567051ae7f7SPaul Mackerras } 568d20a47e7SNamhyung Kim child_pid = evsel_list->workload.pid; 56960666c63SLiming Wang } 570051ae7f7SPaul Mackerras 5716a4bb04cSJiri Olsa if (group) 57263dab225SArnaldo Carvalho de Melo perf_evlist__set_leader(evsel_list); 5736a4bb04cSJiri Olsa 574e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 57542ef8a78SArnaldo Carvalho de Melo try_again: 576cac21425SJiri Olsa if (create_perf_stat_counter(counter) < 0) { 577979987a5SDavid Ahern /* 578979987a5SDavid Ahern * PPC returns ENXIO for HW counters until 2.6.37 579979987a5SDavid Ahern * (behavior changed with commit b0a873e). 580979987a5SDavid Ahern */ 58138f6ae1eSAnton Blanchard if (errno == EINVAL || errno == ENOSYS || 582979987a5SDavid Ahern errno == ENOENT || errno == EOPNOTSUPP || 583979987a5SDavid Ahern errno == ENXIO) { 584bb963e16SNamhyung Kim if (verbose > 0) 585c63ca0c0SDavid Ahern ui__warning("%s event is not supported by the kernel.\n", 5867289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 5872cee77c4SDavid Ahern counter->supported = false; 588cb5ef600SKan Liang 589cb5ef600SKan Liang if ((counter->leader != counter) || 590cb5ef600SKan Liang !(counter->leader->nr_members > 1)) 591ede70290SIngo Molnar continue; 59242ef8a78SArnaldo Carvalho de Melo } else if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) { 593bb963e16SNamhyung Kim if (verbose > 0) 59442ef8a78SArnaldo Carvalho de Melo ui__warning("%s\n", msg); 59542ef8a78SArnaldo Carvalho de Melo goto try_again; 596c63ca0c0SDavid Ahern } 597ede70290SIngo Molnar 59856e52e85SArnaldo Carvalho de Melo perf_evsel__open_strerror(counter, &target, 59956e52e85SArnaldo Carvalho de Melo errno, msg, sizeof(msg)); 60056e52e85SArnaldo Carvalho de Melo ui__error("%s\n", msg); 60156e52e85SArnaldo Carvalho de Melo 602084ab9f8SArnaldo Carvalho de Melo if (child_pid != -1) 603084ab9f8SArnaldo Carvalho de Melo kill(child_pid, SIGTERM); 604fceda7feSDavid Ahern 605084ab9f8SArnaldo Carvalho de Melo return -1; 606084ab9f8SArnaldo Carvalho de Melo } 6072cee77c4SDavid Ahern counter->supported = true; 608410136f5SStephane Eranian 609410136f5SStephane Eranian l = strlen(counter->unit); 610410136f5SStephane Eranian if (l > unit_width) 611410136f5SStephane Eranian unit_width = l; 6122af4646dSJiri Olsa 6132af4646dSJiri Olsa if (STAT_RECORD && store_counter_ids(counter)) 6142af4646dSJiri Olsa return -1; 61548290609SArnaldo Carvalho de Melo } 61686470930SIngo Molnar 61723d4aad4SArnaldo Carvalho de Melo if (perf_evlist__apply_filters(evsel_list, &counter)) { 61823d4aad4SArnaldo Carvalho de Melo error("failed to set filter \"%s\" on event %s with %d (%s)\n", 61923d4aad4SArnaldo Carvalho de Melo counter->filter, perf_evsel__name(counter), errno, 620c8b5f2c9SArnaldo Carvalho de Melo str_error_r(errno, msg, sizeof(msg))); 621cfd748aeSFrederic Weisbecker return -1; 622cfd748aeSFrederic Weisbecker } 623cfd748aeSFrederic Weisbecker 6245d8bb1ecSMathieu Poirier if (perf_evlist__apply_drv_configs(evsel_list, &counter, &err_term)) { 6255d8bb1ecSMathieu Poirier error("failed to set config \"%s\" on event %s with %d (%s)\n", 6265d8bb1ecSMathieu Poirier err_term->val.drv_cfg, perf_evsel__name(counter), errno, 6275d8bb1ecSMathieu Poirier str_error_r(errno, msg, sizeof(msg))); 6285d8bb1ecSMathieu Poirier return -1; 6295d8bb1ecSMathieu Poirier } 6305d8bb1ecSMathieu Poirier 6314979d0c7SJiri Olsa if (STAT_RECORD) { 6324979d0c7SJiri Olsa int err, fd = perf_data_file__fd(&perf_stat.file); 6334979d0c7SJiri Olsa 634664c98d4SJiri Olsa if (is_pipe) { 635664c98d4SJiri Olsa err = perf_header__write_pipe(perf_data_file__fd(&perf_stat.file)); 636664c98d4SJiri Olsa } else { 6374979d0c7SJiri Olsa err = perf_session__write_header(perf_stat.session, evsel_list, 6384979d0c7SJiri Olsa fd, false); 639664c98d4SJiri Olsa } 640664c98d4SJiri Olsa 6414979d0c7SJiri Olsa if (err < 0) 6424979d0c7SJiri Olsa return err; 6438b99b1a4SJiri Olsa 644664c98d4SJiri Olsa err = perf_stat_synthesize_config(is_pipe); 6458b99b1a4SJiri Olsa if (err < 0) 6468b99b1a4SJiri Olsa return err; 6474979d0c7SJiri Olsa } 6484979d0c7SJiri Olsa 64986470930SIngo Molnar /* 65086470930SIngo Molnar * Enable counters and exec the command: 65186470930SIngo Molnar */ 65286470930SIngo Molnar t0 = rdclock(); 65313370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ref_time); 65486470930SIngo Molnar 65560666c63SLiming Wang if (forks) { 656acf28922SNamhyung Kim perf_evlist__start_workload(evsel_list); 65767ccdecdSJiri Olsa enable_counters(); 658acf28922SNamhyung Kim 65913370a9bSStephane Eranian if (interval) { 66013370a9bSStephane Eranian while (!waitpid(child_pid, &status, WNOHANG)) { 66113370a9bSStephane Eranian nanosleep(&ts, NULL); 662ba411a95SJiri Olsa process_interval(); 66313370a9bSStephane Eranian } 66413370a9bSStephane Eranian } 66542202dd5SIngo Molnar wait(&status); 6666af206fdSArnaldo Carvalho de Melo 667f33cbe72SArnaldo Carvalho de Melo if (workload_exec_errno) { 668c8b5f2c9SArnaldo Carvalho de Melo const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg)); 669f33cbe72SArnaldo Carvalho de Melo pr_err("Workload failed: %s\n", emsg); 6706af206fdSArnaldo Carvalho de Melo return -1; 671f33cbe72SArnaldo Carvalho de Melo } 6726af206fdSArnaldo Carvalho de Melo 67333e49ea7SAndi Kleen if (WIFSIGNALED(status)) 67433e49ea7SAndi Kleen psignal(WTERMSIG(status), argv[0]); 67560666c63SLiming Wang } else { 67667ccdecdSJiri Olsa enable_counters(); 67713370a9bSStephane Eranian while (!done) { 67813370a9bSStephane Eranian nanosleep(&ts, NULL); 67913370a9bSStephane Eranian if (interval) 680ba411a95SJiri Olsa process_interval(); 68113370a9bSStephane Eranian } 68260666c63SLiming Wang } 68386470930SIngo Molnar 6843df33effSMark Rutland disable_counters(); 6853df33effSMark Rutland 68686470930SIngo Molnar t1 = rdclock(); 68786470930SIngo Molnar 6889e9772c4SPeter Zijlstra update_stats(&walltime_nsecs_stats, t1 - t0); 68942202dd5SIngo Molnar 6903df33effSMark Rutland /* 6913df33effSMark Rutland * Closing a group leader splits the group, and as we only disable 6923df33effSMark Rutland * group leaders, results in remaining events becoming enabled. To 6933df33effSMark Rutland * avoid arbitrary skew, we must read all counters before closing any 6943df33effSMark Rutland * group leaders. 6953df33effSMark Rutland */ 6963df33effSMark Rutland read_counters(); 6973df33effSMark Rutland perf_evlist__close(evsel_list); 698c52b12edSArnaldo Carvalho de Melo 69942202dd5SIngo Molnar return WEXITSTATUS(status); 70042202dd5SIngo Molnar } 70142202dd5SIngo Molnar 70241cde476SArnaldo Carvalho de Melo static int run_perf_stat(int argc, const char **argv) 7031f16c575SPeter Zijlstra { 7041f16c575SPeter Zijlstra int ret; 7051f16c575SPeter Zijlstra 7061f16c575SPeter Zijlstra if (pre_cmd) { 7071f16c575SPeter Zijlstra ret = system(pre_cmd); 7081f16c575SPeter Zijlstra if (ret) 7091f16c575SPeter Zijlstra return ret; 7101f16c575SPeter Zijlstra } 7111f16c575SPeter Zijlstra 7121f16c575SPeter Zijlstra if (sync_run) 7131f16c575SPeter Zijlstra sync(); 7141f16c575SPeter Zijlstra 7151f16c575SPeter Zijlstra ret = __run_perf_stat(argc, argv); 7161f16c575SPeter Zijlstra if (ret) 7171f16c575SPeter Zijlstra return ret; 7181f16c575SPeter Zijlstra 7191f16c575SPeter Zijlstra if (post_cmd) { 7201f16c575SPeter Zijlstra ret = system(post_cmd); 7211f16c575SPeter Zijlstra if (ret) 7221f16c575SPeter Zijlstra return ret; 7231f16c575SPeter Zijlstra } 7241f16c575SPeter Zijlstra 7251f16c575SPeter Zijlstra return ret; 7261f16c575SPeter Zijlstra } 7271f16c575SPeter Zijlstra 728d73515c0SAndi Kleen static void print_running(u64 run, u64 ena) 729d73515c0SAndi Kleen { 730d73515c0SAndi Kleen if (csv_output) { 7315821522eSJiri Olsa fprintf(stat_config.output, "%s%" PRIu64 "%s%.2f", 732d73515c0SAndi Kleen csv_sep, 733d73515c0SAndi Kleen run, 734d73515c0SAndi Kleen csv_sep, 735d73515c0SAndi Kleen ena ? 100.0 * run / ena : 100.0); 736d73515c0SAndi Kleen } else if (run != ena) { 7375821522eSJiri Olsa fprintf(stat_config.output, " (%.2f%%)", 100.0 * run / ena); 738d73515c0SAndi Kleen } 739d73515c0SAndi Kleen } 740d73515c0SAndi Kleen 741f99844cbSIngo Molnar static void print_noise_pct(double total, double avg) 742f99844cbSIngo Molnar { 7430007eceaSXiao Guangrong double pct = rel_stddev_stats(total, avg); 744f99844cbSIngo Molnar 7453ae9a34dSZhengyu He if (csv_output) 7465821522eSJiri Olsa fprintf(stat_config.output, "%s%.2f%%", csv_sep, pct); 747a1bca6ccSJim Cromie else if (pct) 7485821522eSJiri Olsa fprintf(stat_config.output, " ( +-%6.2f%% )", pct); 749f99844cbSIngo Molnar } 750f99844cbSIngo Molnar 75169aad6f1SArnaldo Carvalho de Melo static void print_noise(struct perf_evsel *evsel, double avg) 75242202dd5SIngo Molnar { 753581cc8a2SJiri Olsa struct perf_stat_evsel *ps; 75469aad6f1SArnaldo Carvalho de Melo 755849abde9SPeter Zijlstra if (run_count == 1) 756849abde9SPeter Zijlstra return; 757849abde9SPeter Zijlstra 75869aad6f1SArnaldo Carvalho de Melo ps = evsel->priv; 759f99844cbSIngo Molnar print_noise_pct(stddev_stats(&ps->res_stats[0]), avg); 76042202dd5SIngo Molnar } 76142202dd5SIngo Molnar 76212c08a9fSStephane Eranian static void aggr_printout(struct perf_evsel *evsel, int id, int nr) 76342202dd5SIngo Molnar { 764421a50f3SJiri Olsa switch (stat_config.aggr_mode) { 76512c08a9fSStephane Eranian case AGGR_CORE: 7665821522eSJiri Olsa fprintf(stat_config.output, "S%d-C%*d%s%*d%s", 76712c08a9fSStephane Eranian cpu_map__id_to_socket(id), 76812c08a9fSStephane Eranian csv_output ? 0 : -8, 76912c08a9fSStephane Eranian cpu_map__id_to_cpu(id), 77012c08a9fSStephane Eranian csv_sep, 77112c08a9fSStephane Eranian csv_output ? 0 : 4, 77212c08a9fSStephane Eranian nr, 77312c08a9fSStephane Eranian csv_sep); 77412c08a9fSStephane Eranian break; 77586ee6e18SStephane Eranian case AGGR_SOCKET: 7765821522eSJiri Olsa fprintf(stat_config.output, "S%*d%s%*d%s", 777d7e7a451SStephane Eranian csv_output ? 0 : -5, 77812c08a9fSStephane Eranian id, 779d7e7a451SStephane Eranian csv_sep, 780d7e7a451SStephane Eranian csv_output ? 0 : 4, 781d7e7a451SStephane Eranian nr, 782d7e7a451SStephane Eranian csv_sep); 78386ee6e18SStephane Eranian break; 78486ee6e18SStephane Eranian case AGGR_NONE: 7855821522eSJiri Olsa fprintf(stat_config.output, "CPU%*d%s", 786d7470b6aSStephane Eranian csv_output ? 0 : -4, 78712c08a9fSStephane Eranian perf_evsel__cpus(evsel)->map[id], csv_sep); 78886ee6e18SStephane Eranian break; 78932b8af82SJiri Olsa case AGGR_THREAD: 7905821522eSJiri Olsa fprintf(stat_config.output, "%*s-%*d%s", 79132b8af82SJiri Olsa csv_output ? 0 : 16, 79232b8af82SJiri Olsa thread_map__comm(evsel->threads, id), 79332b8af82SJiri Olsa csv_output ? 0 : -8, 79432b8af82SJiri Olsa thread_map__pid(evsel->threads, id), 79532b8af82SJiri Olsa csv_sep); 79632b8af82SJiri Olsa break; 79786ee6e18SStephane Eranian case AGGR_GLOBAL: 798208df99eSJiri Olsa case AGGR_UNSET: 79986ee6e18SStephane Eranian default: 80086ee6e18SStephane Eranian break; 80186ee6e18SStephane Eranian } 80286ee6e18SStephane Eranian } 803d7470b6aSStephane Eranian 804140aeadcSAndi Kleen struct outstate { 805140aeadcSAndi Kleen FILE *fh; 806140aeadcSAndi Kleen bool newline; 807f9483392SAndi Kleen const char *prefix; 80892a61f64SAndi Kleen int nfields; 80944d49a60SAndi Kleen int id, nr; 81044d49a60SAndi Kleen struct perf_evsel *evsel; 811140aeadcSAndi Kleen }; 812140aeadcSAndi Kleen 813140aeadcSAndi Kleen #define METRIC_LEN 35 814140aeadcSAndi Kleen 815140aeadcSAndi Kleen static void new_line_std(void *ctx) 816140aeadcSAndi Kleen { 817140aeadcSAndi Kleen struct outstate *os = ctx; 818140aeadcSAndi Kleen 819140aeadcSAndi Kleen os->newline = true; 820140aeadcSAndi Kleen } 821140aeadcSAndi Kleen 822140aeadcSAndi Kleen static void do_new_line_std(struct outstate *os) 823140aeadcSAndi Kleen { 824140aeadcSAndi Kleen fputc('\n', os->fh); 825f9483392SAndi Kleen fputs(os->prefix, os->fh); 82644d49a60SAndi Kleen aggr_printout(os->evsel, os->id, os->nr); 827140aeadcSAndi Kleen if (stat_config.aggr_mode == AGGR_NONE) 828140aeadcSAndi Kleen fprintf(os->fh, " "); 829140aeadcSAndi Kleen fprintf(os->fh, " "); 830140aeadcSAndi Kleen } 831140aeadcSAndi Kleen 832140aeadcSAndi Kleen static void print_metric_std(void *ctx, const char *color, const char *fmt, 833140aeadcSAndi Kleen const char *unit, double val) 834140aeadcSAndi Kleen { 835140aeadcSAndi Kleen struct outstate *os = ctx; 836140aeadcSAndi Kleen FILE *out = os->fh; 837140aeadcSAndi Kleen int n; 838140aeadcSAndi Kleen bool newline = os->newline; 839140aeadcSAndi Kleen 840140aeadcSAndi Kleen os->newline = false; 841140aeadcSAndi Kleen 842140aeadcSAndi Kleen if (unit == NULL || fmt == NULL) { 843140aeadcSAndi Kleen fprintf(out, "%-*s", METRIC_LEN, ""); 844140aeadcSAndi Kleen return; 845140aeadcSAndi Kleen } 846140aeadcSAndi Kleen 847140aeadcSAndi Kleen if (newline) 848140aeadcSAndi Kleen do_new_line_std(os); 849140aeadcSAndi Kleen 850140aeadcSAndi Kleen n = fprintf(out, " # "); 851140aeadcSAndi Kleen if (color) 852140aeadcSAndi Kleen n += color_fprintf(out, color, fmt, val); 853140aeadcSAndi Kleen else 854140aeadcSAndi Kleen n += fprintf(out, fmt, val); 855140aeadcSAndi Kleen fprintf(out, " %-*s", METRIC_LEN - n - 1, unit); 856140aeadcSAndi Kleen } 857140aeadcSAndi Kleen 85892a61f64SAndi Kleen static void new_line_csv(void *ctx) 85992a61f64SAndi Kleen { 86092a61f64SAndi Kleen struct outstate *os = ctx; 86192a61f64SAndi Kleen int i; 86292a61f64SAndi Kleen 86392a61f64SAndi Kleen fputc('\n', os->fh); 86492a61f64SAndi Kleen if (os->prefix) 86592a61f64SAndi Kleen fprintf(os->fh, "%s%s", os->prefix, csv_sep); 86644d49a60SAndi Kleen aggr_printout(os->evsel, os->id, os->nr); 86792a61f64SAndi Kleen for (i = 0; i < os->nfields; i++) 86892a61f64SAndi Kleen fputs(csv_sep, os->fh); 86992a61f64SAndi Kleen } 87092a61f64SAndi Kleen 87192a61f64SAndi Kleen static void print_metric_csv(void *ctx, 87292a61f64SAndi Kleen const char *color __maybe_unused, 87392a61f64SAndi Kleen const char *fmt, const char *unit, double val) 87492a61f64SAndi Kleen { 87592a61f64SAndi Kleen struct outstate *os = ctx; 87692a61f64SAndi Kleen FILE *out = os->fh; 87792a61f64SAndi Kleen char buf[64], *vals, *ends; 87892a61f64SAndi Kleen 87992a61f64SAndi Kleen if (unit == NULL || fmt == NULL) { 88092a61f64SAndi Kleen fprintf(out, "%s%s%s%s", csv_sep, csv_sep, csv_sep, csv_sep); 88192a61f64SAndi Kleen return; 88292a61f64SAndi Kleen } 88392a61f64SAndi Kleen snprintf(buf, sizeof(buf), fmt, val); 884b07c40dfSTaeung Song ends = vals = ltrim(buf); 88592a61f64SAndi Kleen while (isdigit(*ends) || *ends == '.') 88692a61f64SAndi Kleen ends++; 88792a61f64SAndi Kleen *ends = 0; 88892a61f64SAndi Kleen while (isspace(*unit)) 88992a61f64SAndi Kleen unit++; 89092a61f64SAndi Kleen fprintf(out, "%s%s%s%s", csv_sep, vals, csv_sep, unit); 89192a61f64SAndi Kleen } 89292a61f64SAndi Kleen 89354b50916SAndi Kleen #define METRIC_ONLY_LEN 20 89454b50916SAndi Kleen 89554b50916SAndi Kleen /* Filter out some columns that don't work well in metrics only mode */ 89654b50916SAndi Kleen 89754b50916SAndi Kleen static bool valid_only_metric(const char *unit) 89854b50916SAndi Kleen { 89954b50916SAndi Kleen if (!unit) 90054b50916SAndi Kleen return false; 90154b50916SAndi Kleen if (strstr(unit, "/sec") || 90254b50916SAndi Kleen strstr(unit, "hz") || 90354b50916SAndi Kleen strstr(unit, "Hz") || 90454b50916SAndi Kleen strstr(unit, "CPUs utilized")) 90554b50916SAndi Kleen return false; 90654b50916SAndi Kleen return true; 90754b50916SAndi Kleen } 90854b50916SAndi Kleen 90954b50916SAndi Kleen static const char *fixunit(char *buf, struct perf_evsel *evsel, 91054b50916SAndi Kleen const char *unit) 91154b50916SAndi Kleen { 91254b50916SAndi Kleen if (!strncmp(unit, "of all", 6)) { 91354b50916SAndi Kleen snprintf(buf, 1024, "%s %s", perf_evsel__name(evsel), 91454b50916SAndi Kleen unit); 91554b50916SAndi Kleen return buf; 91654b50916SAndi Kleen } 91754b50916SAndi Kleen return unit; 91854b50916SAndi Kleen } 91954b50916SAndi Kleen 92054b50916SAndi Kleen static void print_metric_only(void *ctx, const char *color, const char *fmt, 92154b50916SAndi Kleen const char *unit, double val) 92254b50916SAndi Kleen { 92354b50916SAndi Kleen struct outstate *os = ctx; 92454b50916SAndi Kleen FILE *out = os->fh; 92554b50916SAndi Kleen int n; 92654b50916SAndi Kleen char buf[1024]; 92754b50916SAndi Kleen unsigned mlen = METRIC_ONLY_LEN; 92854b50916SAndi Kleen 92954b50916SAndi Kleen if (!valid_only_metric(unit)) 93054b50916SAndi Kleen return; 93154b50916SAndi Kleen unit = fixunit(buf, os->evsel, unit); 93254b50916SAndi Kleen if (color) 93354b50916SAndi Kleen n = color_fprintf(out, color, fmt, val); 93454b50916SAndi Kleen else 93554b50916SAndi Kleen n = fprintf(out, fmt, val); 93654b50916SAndi Kleen if (n > METRIC_ONLY_LEN) 93754b50916SAndi Kleen n = METRIC_ONLY_LEN; 93854b50916SAndi Kleen if (mlen < strlen(unit)) 93954b50916SAndi Kleen mlen = strlen(unit) + 1; 94054b50916SAndi Kleen fprintf(out, "%*s", mlen - n, ""); 94154b50916SAndi Kleen } 94254b50916SAndi Kleen 94354b50916SAndi Kleen static void print_metric_only_csv(void *ctx, const char *color __maybe_unused, 94454b50916SAndi Kleen const char *fmt, 94554b50916SAndi Kleen const char *unit, double val) 94654b50916SAndi Kleen { 94754b50916SAndi Kleen struct outstate *os = ctx; 94854b50916SAndi Kleen FILE *out = os->fh; 94954b50916SAndi Kleen char buf[64], *vals, *ends; 95054b50916SAndi Kleen char tbuf[1024]; 95154b50916SAndi Kleen 95254b50916SAndi Kleen if (!valid_only_metric(unit)) 95354b50916SAndi Kleen return; 95454b50916SAndi Kleen unit = fixunit(tbuf, os->evsel, unit); 95554b50916SAndi Kleen snprintf(buf, sizeof buf, fmt, val); 956b07c40dfSTaeung Song ends = vals = ltrim(buf); 95754b50916SAndi Kleen while (isdigit(*ends) || *ends == '.') 95854b50916SAndi Kleen ends++; 95954b50916SAndi Kleen *ends = 0; 96054b50916SAndi Kleen fprintf(out, "%s%s", vals, csv_sep); 96154b50916SAndi Kleen } 96254b50916SAndi Kleen 96354b50916SAndi Kleen static void new_line_metric(void *ctx __maybe_unused) 96454b50916SAndi Kleen { 96554b50916SAndi Kleen } 96654b50916SAndi Kleen 96754b50916SAndi Kleen static void print_metric_header(void *ctx, const char *color __maybe_unused, 96854b50916SAndi Kleen const char *fmt __maybe_unused, 96954b50916SAndi Kleen const char *unit, double val __maybe_unused) 97054b50916SAndi Kleen { 97154b50916SAndi Kleen struct outstate *os = ctx; 97254b50916SAndi Kleen char tbuf[1024]; 97354b50916SAndi Kleen 97454b50916SAndi Kleen if (!valid_only_metric(unit)) 97554b50916SAndi Kleen return; 97654b50916SAndi Kleen unit = fixunit(tbuf, os->evsel, unit); 97754b50916SAndi Kleen if (csv_output) 97854b50916SAndi Kleen fprintf(os->fh, "%s%s", unit, csv_sep); 97954b50916SAndi Kleen else 98054b50916SAndi Kleen fprintf(os->fh, "%-*s ", METRIC_ONLY_LEN, unit); 98154b50916SAndi Kleen } 98254b50916SAndi Kleen 983da88c7f7SAndi Kleen static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg) 98486ee6e18SStephane Eranian { 9855821522eSJiri Olsa FILE *output = stat_config.output; 986310ebb93SArnaldo Carvalho de Melo double msecs = avg / NSEC_PER_MSEC; 987410136f5SStephane Eranian const char *fmt_v, *fmt_n; 9884bbe5a61SDavid Ahern char name[25]; 98986ee6e18SStephane Eranian 990410136f5SStephane Eranian fmt_v = csv_output ? "%.6f%s" : "%18.6f%s"; 991410136f5SStephane Eranian fmt_n = csv_output ? "%s" : "%-25s"; 992410136f5SStephane Eranian 993da88c7f7SAndi Kleen aggr_printout(evsel, id, nr); 99486ee6e18SStephane Eranian 9954bbe5a61SDavid Ahern scnprintf(name, sizeof(name), "%s%s", 9964bbe5a61SDavid Ahern perf_evsel__name(evsel), csv_output ? "" : " (msec)"); 997410136f5SStephane Eranian 998410136f5SStephane Eranian fprintf(output, fmt_v, msecs, csv_sep); 999410136f5SStephane Eranian 1000410136f5SStephane Eranian if (csv_output) 1001410136f5SStephane Eranian fprintf(output, "%s%s", evsel->unit, csv_sep); 1002410136f5SStephane Eranian else 1003410136f5SStephane Eranian fprintf(output, "%-*s%s", unit_width, evsel->unit, csv_sep); 1004410136f5SStephane Eranian 1005410136f5SStephane Eranian fprintf(output, fmt_n, name); 1006d7470b6aSStephane Eranian 1007023695d9SStephane Eranian if (evsel->cgrp) 10084aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, evsel->cgrp->name); 100942202dd5SIngo Molnar } 101042202dd5SIngo Molnar 101144d49a60SAndi Kleen static int first_shadow_cpu(struct perf_evsel *evsel, int id) 101244d49a60SAndi Kleen { 101344d49a60SAndi Kleen int i; 101444d49a60SAndi Kleen 101544d49a60SAndi Kleen if (!aggr_get_id) 101644d49a60SAndi Kleen return 0; 101744d49a60SAndi Kleen 101844d49a60SAndi Kleen if (stat_config.aggr_mode == AGGR_NONE) 101944d49a60SAndi Kleen return id; 102044d49a60SAndi Kleen 102144d49a60SAndi Kleen if (stat_config.aggr_mode == AGGR_GLOBAL) 102244d49a60SAndi Kleen return 0; 102344d49a60SAndi Kleen 102444d49a60SAndi Kleen for (i = 0; i < perf_evsel__nr_cpus(evsel); i++) { 102544d49a60SAndi Kleen int cpu2 = perf_evsel__cpus(evsel)->map[i]; 102644d49a60SAndi Kleen 102744d49a60SAndi Kleen if (aggr_get_id(evsel_list->cpus, cpu2) == id) 102844d49a60SAndi Kleen return cpu2; 102944d49a60SAndi Kleen } 103044d49a60SAndi Kleen return 0; 103144d49a60SAndi Kleen } 103244d49a60SAndi Kleen 1033556b1fb7SJiri Olsa static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg) 1034556b1fb7SJiri Olsa { 10355821522eSJiri Olsa FILE *output = stat_config.output; 1036556b1fb7SJiri Olsa double sc = evsel->scale; 1037556b1fb7SJiri Olsa const char *fmt; 1038556b1fb7SJiri Olsa 1039556b1fb7SJiri Olsa if (csv_output) { 1040e3b03b6cSAndi Kleen fmt = floor(sc) != sc ? "%.2f%s" : "%.0f%s"; 1041556b1fb7SJiri Olsa } else { 1042556b1fb7SJiri Olsa if (big_num) 1043e3b03b6cSAndi Kleen fmt = floor(sc) != sc ? "%'18.2f%s" : "%'18.0f%s"; 1044556b1fb7SJiri Olsa else 1045e3b03b6cSAndi Kleen fmt = floor(sc) != sc ? "%18.2f%s" : "%18.0f%s"; 1046556b1fb7SJiri Olsa } 1047556b1fb7SJiri Olsa 1048556b1fb7SJiri Olsa aggr_printout(evsel, id, nr); 1049556b1fb7SJiri Olsa 1050556b1fb7SJiri Olsa fprintf(output, fmt, avg, csv_sep); 1051556b1fb7SJiri Olsa 1052556b1fb7SJiri Olsa if (evsel->unit) 1053556b1fb7SJiri Olsa fprintf(output, "%-*s%s", 1054556b1fb7SJiri Olsa csv_output ? 0 : unit_width, 1055556b1fb7SJiri Olsa evsel->unit, csv_sep); 1056556b1fb7SJiri Olsa 1057556b1fb7SJiri Olsa fprintf(output, "%-*s", csv_output ? 0 : 25, perf_evsel__name(evsel)); 1058556b1fb7SJiri Olsa 1059556b1fb7SJiri Olsa if (evsel->cgrp) 1060556b1fb7SJiri Olsa fprintf(output, "%s%s", csv_sep, evsel->cgrp->name); 1061eedfcb4bSAndi Kleen } 1062556b1fb7SJiri Olsa 1063f9483392SAndi Kleen static void printout(int id, int nr, struct perf_evsel *counter, double uval, 1064cb110f47SAndi Kleen char *prefix, u64 run, u64 ena, double noise) 1065eedfcb4bSAndi Kleen { 1066140aeadcSAndi Kleen struct perf_stat_output_ctx out; 1067f9483392SAndi Kleen struct outstate os = { 1068f9483392SAndi Kleen .fh = stat_config.output, 106944d49a60SAndi Kleen .prefix = prefix ? prefix : "", 107044d49a60SAndi Kleen .id = id, 107144d49a60SAndi Kleen .nr = nr, 107244d49a60SAndi Kleen .evsel = counter, 1073f9483392SAndi Kleen }; 1074140aeadcSAndi Kleen print_metric_t pm = print_metric_std; 1075140aeadcSAndi Kleen void (*nl)(void *); 1076556b1fb7SJiri Olsa 107754b50916SAndi Kleen if (metric_only) { 107854b50916SAndi Kleen nl = new_line_metric; 107954b50916SAndi Kleen if (csv_output) 108054b50916SAndi Kleen pm = print_metric_only_csv; 108154b50916SAndi Kleen else 108254b50916SAndi Kleen pm = print_metric_only; 108354b50916SAndi Kleen } else 1084140aeadcSAndi Kleen nl = new_line_std; 1085eedfcb4bSAndi Kleen 108654b50916SAndi Kleen if (csv_output && !metric_only) { 108792a61f64SAndi Kleen static int aggr_fields[] = { 108892a61f64SAndi Kleen [AGGR_GLOBAL] = 0, 108992a61f64SAndi Kleen [AGGR_THREAD] = 1, 109092a61f64SAndi Kleen [AGGR_NONE] = 1, 109192a61f64SAndi Kleen [AGGR_SOCKET] = 2, 109292a61f64SAndi Kleen [AGGR_CORE] = 2, 109392a61f64SAndi Kleen }; 109492a61f64SAndi Kleen 109592a61f64SAndi Kleen pm = print_metric_csv; 109692a61f64SAndi Kleen nl = new_line_csv; 109792a61f64SAndi Kleen os.nfields = 3; 109892a61f64SAndi Kleen os.nfields += aggr_fields[stat_config.aggr_mode]; 109992a61f64SAndi Kleen if (counter->cgrp) 110092a61f64SAndi Kleen os.nfields++; 110192a61f64SAndi Kleen } 1102b002f3bbSAndi Kleen if (run == 0 || ena == 0 || counter->counts->scaled == -1) { 110354b50916SAndi Kleen if (metric_only) { 110454b50916SAndi Kleen pm(&os, NULL, "", "", 0); 110554b50916SAndi Kleen return; 110654b50916SAndi Kleen } 1107cb110f47SAndi Kleen aggr_printout(counter, id, nr); 1108cb110f47SAndi Kleen 1109cb110f47SAndi Kleen fprintf(stat_config.output, "%*s%s", 1110cb110f47SAndi Kleen csv_output ? 0 : 18, 1111cb110f47SAndi Kleen counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1112cb110f47SAndi Kleen csv_sep); 1113cb110f47SAndi Kleen 111402d492e5SBorislav Petkov if (counter->supported) 111502d492e5SBorislav Petkov print_free_counters_hint = 1; 111602d492e5SBorislav Petkov 1117cb110f47SAndi Kleen fprintf(stat_config.output, "%-*s%s", 1118cb110f47SAndi Kleen csv_output ? 0 : unit_width, 1119cb110f47SAndi Kleen counter->unit, csv_sep); 1120cb110f47SAndi Kleen 1121cb110f47SAndi Kleen fprintf(stat_config.output, "%*s", 1122cb110f47SAndi Kleen csv_output ? 0 : -25, 1123cb110f47SAndi Kleen perf_evsel__name(counter)); 1124cb110f47SAndi Kleen 1125cb110f47SAndi Kleen if (counter->cgrp) 1126cb110f47SAndi Kleen fprintf(stat_config.output, "%s%s", 1127cb110f47SAndi Kleen csv_sep, counter->cgrp->name); 1128cb110f47SAndi Kleen 112992a61f64SAndi Kleen if (!csv_output) 113092a61f64SAndi Kleen pm(&os, NULL, NULL, "", 0); 113192a61f64SAndi Kleen print_noise(counter, noise); 1132cb110f47SAndi Kleen print_running(run, ena); 113392a61f64SAndi Kleen if (csv_output) 113492a61f64SAndi Kleen pm(&os, NULL, NULL, "", 0); 1135cb110f47SAndi Kleen return; 1136cb110f47SAndi Kleen } 1137cb110f47SAndi Kleen 113854b50916SAndi Kleen if (metric_only) 113954b50916SAndi Kleen /* nothing */; 114054b50916SAndi Kleen else if (nsec_counter(counter)) 1141eedfcb4bSAndi Kleen nsec_printout(id, nr, counter, uval); 1142eedfcb4bSAndi Kleen else 1143eedfcb4bSAndi Kleen abs_printout(id, nr, counter, uval); 1144eedfcb4bSAndi Kleen 1145140aeadcSAndi Kleen out.print_metric = pm; 1146140aeadcSAndi Kleen out.new_line = nl; 1147140aeadcSAndi Kleen out.ctx = &os; 114837932c18SAndi Kleen out.force_header = false; 1149140aeadcSAndi Kleen 115054b50916SAndi Kleen if (csv_output && !metric_only) { 115192a61f64SAndi Kleen print_noise(counter, noise); 115292a61f64SAndi Kleen print_running(run, ena); 115392a61f64SAndi Kleen } 115492a61f64SAndi Kleen 1155140aeadcSAndi Kleen perf_stat__print_shadow_stats(counter, uval, 115644d49a60SAndi Kleen first_shadow_cpu(counter, id), 1157140aeadcSAndi Kleen &out); 115854b50916SAndi Kleen if (!csv_output && !metric_only) { 1159cb110f47SAndi Kleen print_noise(counter, noise); 1160cb110f47SAndi Kleen print_running(run, ena); 1161556b1fb7SJiri Olsa } 116292a61f64SAndi Kleen } 1163556b1fb7SJiri Olsa 116444d49a60SAndi Kleen static void aggr_update_shadow(void) 116544d49a60SAndi Kleen { 116644d49a60SAndi Kleen int cpu, s2, id, s; 116744d49a60SAndi Kleen u64 val; 116844d49a60SAndi Kleen struct perf_evsel *counter; 116944d49a60SAndi Kleen 117044d49a60SAndi Kleen for (s = 0; s < aggr_map->nr; s++) { 117144d49a60SAndi Kleen id = aggr_map->map[s]; 1172e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 117344d49a60SAndi Kleen val = 0; 117444d49a60SAndi Kleen for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 117544d49a60SAndi Kleen s2 = aggr_get_id(evsel_list->cpus, cpu); 117644d49a60SAndi Kleen if (s2 != id) 117744d49a60SAndi Kleen continue; 117844d49a60SAndi Kleen val += perf_counts(counter->counts, cpu, 0)->val; 117944d49a60SAndi Kleen } 118044d49a60SAndi Kleen val = val * counter->scale; 118144d49a60SAndi Kleen perf_stat__update_shadow_stats(counter, &val, 118244d49a60SAndi Kleen first_shadow_cpu(counter, id)); 118344d49a60SAndi Kleen } 118444d49a60SAndi Kleen } 118544d49a60SAndi Kleen } 118644d49a60SAndi Kleen 1187430daf2dSAndi Kleen static void collect_all_aliases(struct perf_evsel *counter, 1188fbe51fbaSAndi Kleen void (*cb)(struct perf_evsel *counter, void *data, 1189fbe51fbaSAndi Kleen bool first), 1190fbe51fbaSAndi Kleen void *data) 1191fbe51fbaSAndi Kleen { 1192430daf2dSAndi Kleen struct perf_evsel *alias; 1193430daf2dSAndi Kleen 1194430daf2dSAndi Kleen alias = list_prepare_entry(counter, &(evsel_list->entries), node); 1195430daf2dSAndi Kleen list_for_each_entry_continue (alias, &evsel_list->entries, node) { 1196430daf2dSAndi Kleen if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) || 1197430daf2dSAndi Kleen alias->scale != counter->scale || 1198430daf2dSAndi Kleen alias->cgrp != counter->cgrp || 1199430daf2dSAndi Kleen strcmp(alias->unit, counter->unit) || 1200430daf2dSAndi Kleen nsec_counter(alias) != nsec_counter(counter)) 1201430daf2dSAndi Kleen break; 1202430daf2dSAndi Kleen alias->merged_stat = true; 1203430daf2dSAndi Kleen cb(alias, data, false); 1204430daf2dSAndi Kleen } 1205430daf2dSAndi Kleen } 1206430daf2dSAndi Kleen 1207430daf2dSAndi Kleen static bool collect_data(struct perf_evsel *counter, 1208430daf2dSAndi Kleen void (*cb)(struct perf_evsel *counter, void *data, 1209430daf2dSAndi Kleen bool first), 1210430daf2dSAndi Kleen void *data) 1211430daf2dSAndi Kleen { 1212430daf2dSAndi Kleen if (counter->merged_stat) 1213430daf2dSAndi Kleen return false; 1214fbe51fbaSAndi Kleen cb(counter, data, true); 1215430daf2dSAndi Kleen if (!no_merge) 1216430daf2dSAndi Kleen collect_all_aliases(counter, cb, data); 1217430daf2dSAndi Kleen return true; 1218fbe51fbaSAndi Kleen } 1219fbe51fbaSAndi Kleen 1220fbe51fbaSAndi Kleen struct aggr_data { 1221fbe51fbaSAndi Kleen u64 ena, run, val; 1222fbe51fbaSAndi Kleen int id; 1223fbe51fbaSAndi Kleen int nr; 1224fbe51fbaSAndi Kleen int cpu; 1225fbe51fbaSAndi Kleen }; 1226fbe51fbaSAndi Kleen 1227fbe51fbaSAndi Kleen static void aggr_cb(struct perf_evsel *counter, void *data, bool first) 1228fbe51fbaSAndi Kleen { 1229fbe51fbaSAndi Kleen struct aggr_data *ad = data; 1230fbe51fbaSAndi Kleen int cpu, s2; 1231fbe51fbaSAndi Kleen 1232fbe51fbaSAndi Kleen for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1233fbe51fbaSAndi Kleen struct perf_counts_values *counts; 1234fbe51fbaSAndi Kleen 1235fbe51fbaSAndi Kleen s2 = aggr_get_id(perf_evsel__cpus(counter), cpu); 1236fbe51fbaSAndi Kleen if (s2 != ad->id) 1237fbe51fbaSAndi Kleen continue; 1238fbe51fbaSAndi Kleen if (first) 1239fbe51fbaSAndi Kleen ad->nr++; 1240fbe51fbaSAndi Kleen counts = perf_counts(counter->counts, cpu, 0); 1241b4229e9dSAndi Kleen /* 1242b4229e9dSAndi Kleen * When any result is bad, make them all to give 1243b4229e9dSAndi Kleen * consistent output in interval mode. 1244b4229e9dSAndi Kleen */ 1245b4229e9dSAndi Kleen if (counts->ena == 0 || counts->run == 0 || 1246b4229e9dSAndi Kleen counter->counts->scaled == -1) { 1247b4229e9dSAndi Kleen ad->ena = 0; 1248b4229e9dSAndi Kleen ad->run = 0; 1249b4229e9dSAndi Kleen break; 1250b4229e9dSAndi Kleen } 1251fbe51fbaSAndi Kleen ad->val += counts->val; 1252fbe51fbaSAndi Kleen ad->ena += counts->ena; 1253fbe51fbaSAndi Kleen ad->run += counts->run; 1254fbe51fbaSAndi Kleen } 1255fbe51fbaSAndi Kleen } 1256fbe51fbaSAndi Kleen 125786ee6e18SStephane Eranian static void print_aggr(char *prefix) 1258d7e7a451SStephane Eranian { 12595821522eSJiri Olsa FILE *output = stat_config.output; 1260d7e7a451SStephane Eranian struct perf_evsel *counter; 1261fbe51fbaSAndi Kleen int s, id, nr; 1262410136f5SStephane Eranian double uval; 1263d7e7a451SStephane Eranian u64 ena, run, val; 126454b50916SAndi Kleen bool first; 1265d7e7a451SStephane Eranian 126686ee6e18SStephane Eranian if (!(aggr_map || aggr_get_id)) 1267d7e7a451SStephane Eranian return; 1268d7e7a451SStephane Eranian 126944d49a60SAndi Kleen aggr_update_shadow(); 127044d49a60SAndi Kleen 127154b50916SAndi Kleen /* 127254b50916SAndi Kleen * With metric_only everything is on a single line. 127354b50916SAndi Kleen * Without each counter has its own line. 127454b50916SAndi Kleen */ 127586ee6e18SStephane Eranian for (s = 0; s < aggr_map->nr; s++) { 1276fbe51fbaSAndi Kleen struct aggr_data ad; 127754b50916SAndi Kleen if (prefix && metric_only) 127854b50916SAndi Kleen fprintf(output, "%s", prefix); 127954b50916SAndi Kleen 1280fbe51fbaSAndi Kleen ad.id = id = aggr_map->map[s]; 128154b50916SAndi Kleen first = true; 1282e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 1283fbe51fbaSAndi Kleen ad.val = ad.ena = ad.run = 0; 1284fbe51fbaSAndi Kleen ad.nr = 0; 1285430daf2dSAndi Kleen if (!collect_data(counter, aggr_cb, &ad)) 1286430daf2dSAndi Kleen continue; 1287fbe51fbaSAndi Kleen nr = ad.nr; 1288fbe51fbaSAndi Kleen ena = ad.ena; 1289fbe51fbaSAndi Kleen run = ad.run; 1290fbe51fbaSAndi Kleen val = ad.val; 129154b50916SAndi Kleen if (first && metric_only) { 129254b50916SAndi Kleen first = false; 129354b50916SAndi Kleen aggr_printout(counter, id, nr); 129454b50916SAndi Kleen } 129554b50916SAndi Kleen if (prefix && !metric_only) 1296d7e7a451SStephane Eranian fprintf(output, "%s", prefix); 1297d7e7a451SStephane Eranian 1298410136f5SStephane Eranian uval = val * counter->scale; 1299cb110f47SAndi Kleen printout(id, nr, counter, uval, prefix, run, ena, 1.0); 130054b50916SAndi Kleen if (!metric_only) 1301d7e7a451SStephane Eranian fputc('\n', output); 1302d7e7a451SStephane Eranian } 130354b50916SAndi Kleen if (metric_only) 130454b50916SAndi Kleen fputc('\n', output); 1305d7e7a451SStephane Eranian } 1306d7e7a451SStephane Eranian } 1307d7e7a451SStephane Eranian 130832b8af82SJiri Olsa static void print_aggr_thread(struct perf_evsel *counter, char *prefix) 130932b8af82SJiri Olsa { 13105821522eSJiri Olsa FILE *output = stat_config.output; 131132b8af82SJiri Olsa int nthreads = thread_map__nr(counter->threads); 131232b8af82SJiri Olsa int ncpus = cpu_map__nr(counter->cpus); 131332b8af82SJiri Olsa int cpu, thread; 131432b8af82SJiri Olsa double uval; 131532b8af82SJiri Olsa 131632b8af82SJiri Olsa for (thread = 0; thread < nthreads; thread++) { 131732b8af82SJiri Olsa u64 ena = 0, run = 0, val = 0; 131832b8af82SJiri Olsa 131932b8af82SJiri Olsa for (cpu = 0; cpu < ncpus; cpu++) { 132032b8af82SJiri Olsa val += perf_counts(counter->counts, cpu, thread)->val; 132132b8af82SJiri Olsa ena += perf_counts(counter->counts, cpu, thread)->ena; 132232b8af82SJiri Olsa run += perf_counts(counter->counts, cpu, thread)->run; 132332b8af82SJiri Olsa } 132432b8af82SJiri Olsa 132532b8af82SJiri Olsa if (prefix) 132632b8af82SJiri Olsa fprintf(output, "%s", prefix); 132732b8af82SJiri Olsa 132832b8af82SJiri Olsa uval = val * counter->scale; 1329cb110f47SAndi Kleen printout(thread, 0, counter, uval, prefix, run, ena, 1.0); 133032b8af82SJiri Olsa fputc('\n', output); 133132b8af82SJiri Olsa } 133232b8af82SJiri Olsa } 133332b8af82SJiri Olsa 1334fbe51fbaSAndi Kleen struct caggr_data { 1335fbe51fbaSAndi Kleen double avg, avg_enabled, avg_running; 1336fbe51fbaSAndi Kleen }; 1337fbe51fbaSAndi Kleen 1338fbe51fbaSAndi Kleen static void counter_aggr_cb(struct perf_evsel *counter, void *data, 1339fbe51fbaSAndi Kleen bool first __maybe_unused) 1340fbe51fbaSAndi Kleen { 1341fbe51fbaSAndi Kleen struct caggr_data *cd = data; 1342fbe51fbaSAndi Kleen struct perf_stat_evsel *ps = counter->priv; 1343fbe51fbaSAndi Kleen 1344fbe51fbaSAndi Kleen cd->avg += avg_stats(&ps->res_stats[0]); 1345fbe51fbaSAndi Kleen cd->avg_enabled += avg_stats(&ps->res_stats[1]); 1346fbe51fbaSAndi Kleen cd->avg_running += avg_stats(&ps->res_stats[2]); 1347fbe51fbaSAndi Kleen } 1348fbe51fbaSAndi Kleen 134942202dd5SIngo Molnar /* 135042202dd5SIngo Molnar * Print out the results of a single counter: 1351f5b4a9c3SStephane Eranian * aggregated counts in system-wide mode 135242202dd5SIngo Molnar */ 135313370a9bSStephane Eranian static void print_counter_aggr(struct perf_evsel *counter, char *prefix) 135442202dd5SIngo Molnar { 13555821522eSJiri Olsa FILE *output = stat_config.output; 1356410136f5SStephane Eranian double uval; 1357fbe51fbaSAndi Kleen struct caggr_data cd = { .avg = 0.0 }; 1358d73515c0SAndi Kleen 1359430daf2dSAndi Kleen if (!collect_data(counter, counter_aggr_cb, &cd)) 1360430daf2dSAndi Kleen return; 136142202dd5SIngo Molnar 136254b50916SAndi Kleen if (prefix && !metric_only) 136313370a9bSStephane Eranian fprintf(output, "%s", prefix); 136413370a9bSStephane Eranian 1365fbe51fbaSAndi Kleen uval = cd.avg * counter->scale; 1366fbe51fbaSAndi Kleen printout(-1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled, cd.avg); 136754b50916SAndi Kleen if (!metric_only) 13684aa9015fSStephane Eranian fprintf(output, "\n"); 136942202dd5SIngo Molnar } 137042202dd5SIngo Molnar 1371fbe51fbaSAndi Kleen static void counter_cb(struct perf_evsel *counter, void *data, 1372fbe51fbaSAndi Kleen bool first __maybe_unused) 1373fbe51fbaSAndi Kleen { 1374fbe51fbaSAndi Kleen struct aggr_data *ad = data; 1375fbe51fbaSAndi Kleen 1376fbe51fbaSAndi Kleen ad->val += perf_counts(counter->counts, ad->cpu, 0)->val; 1377fbe51fbaSAndi Kleen ad->ena += perf_counts(counter->counts, ad->cpu, 0)->ena; 1378fbe51fbaSAndi Kleen ad->run += perf_counts(counter->counts, ad->cpu, 0)->run; 1379fbe51fbaSAndi Kleen } 1380fbe51fbaSAndi Kleen 1381f5b4a9c3SStephane Eranian /* 1382f5b4a9c3SStephane Eranian * Print out the results of a single counter: 1383f5b4a9c3SStephane Eranian * does not use aggregated count in system-wide 1384f5b4a9c3SStephane Eranian */ 138513370a9bSStephane Eranian static void print_counter(struct perf_evsel *counter, char *prefix) 1386f5b4a9c3SStephane Eranian { 13875821522eSJiri Olsa FILE *output = stat_config.output; 1388f5b4a9c3SStephane Eranian u64 ena, run, val; 1389410136f5SStephane Eranian double uval; 1390f5b4a9c3SStephane Eranian int cpu; 1391f5b4a9c3SStephane Eranian 13927ae92e74SYan, Zheng for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1393fbe51fbaSAndi Kleen struct aggr_data ad = { .cpu = cpu }; 1394fbe51fbaSAndi Kleen 1395430daf2dSAndi Kleen if (!collect_data(counter, counter_cb, &ad)) 1396430daf2dSAndi Kleen return; 1397fbe51fbaSAndi Kleen val = ad.val; 1398fbe51fbaSAndi Kleen ena = ad.ena; 1399fbe51fbaSAndi Kleen run = ad.run; 140013370a9bSStephane Eranian 140113370a9bSStephane Eranian if (prefix) 140213370a9bSStephane Eranian fprintf(output, "%s", prefix); 140313370a9bSStephane Eranian 1404410136f5SStephane Eranian uval = val * counter->scale; 1405cb110f47SAndi Kleen printout(cpu, 0, counter, uval, prefix, run, ena, 1.0); 1406f5b4a9c3SStephane Eranian 14074aa9015fSStephane Eranian fputc('\n', output); 1408f5b4a9c3SStephane Eranian } 1409f5b4a9c3SStephane Eranian } 1410f5b4a9c3SStephane Eranian 1411206cab65SAndi Kleen static void print_no_aggr_metric(char *prefix) 1412206cab65SAndi Kleen { 1413206cab65SAndi Kleen int cpu; 1414206cab65SAndi Kleen int nrcpus = 0; 1415206cab65SAndi Kleen struct perf_evsel *counter; 1416206cab65SAndi Kleen u64 ena, run, val; 1417206cab65SAndi Kleen double uval; 1418206cab65SAndi Kleen 1419206cab65SAndi Kleen nrcpus = evsel_list->cpus->nr; 1420206cab65SAndi Kleen for (cpu = 0; cpu < nrcpus; cpu++) { 1421206cab65SAndi Kleen bool first = true; 1422206cab65SAndi Kleen 1423206cab65SAndi Kleen if (prefix) 1424206cab65SAndi Kleen fputs(prefix, stat_config.output); 1425e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 1426206cab65SAndi Kleen if (first) { 1427206cab65SAndi Kleen aggr_printout(counter, cpu, 0); 1428206cab65SAndi Kleen first = false; 1429206cab65SAndi Kleen } 1430206cab65SAndi Kleen val = perf_counts(counter->counts, cpu, 0)->val; 1431206cab65SAndi Kleen ena = perf_counts(counter->counts, cpu, 0)->ena; 1432206cab65SAndi Kleen run = perf_counts(counter->counts, cpu, 0)->run; 1433206cab65SAndi Kleen 1434206cab65SAndi Kleen uval = val * counter->scale; 1435206cab65SAndi Kleen printout(cpu, 0, counter, uval, prefix, run, ena, 1.0); 1436206cab65SAndi Kleen } 1437206cab65SAndi Kleen fputc('\n', stat_config.output); 1438206cab65SAndi Kleen } 1439206cab65SAndi Kleen } 1440206cab65SAndi Kleen 144154b50916SAndi Kleen static int aggr_header_lens[] = { 144254b50916SAndi Kleen [AGGR_CORE] = 18, 144354b50916SAndi Kleen [AGGR_SOCKET] = 12, 1444206cab65SAndi Kleen [AGGR_NONE] = 6, 144554b50916SAndi Kleen [AGGR_THREAD] = 24, 144654b50916SAndi Kleen [AGGR_GLOBAL] = 0, 144754b50916SAndi Kleen }; 144854b50916SAndi Kleen 1449c51fd639SAndi Kleen static const char *aggr_header_csv[] = { 1450c51fd639SAndi Kleen [AGGR_CORE] = "core,cpus,", 1451c51fd639SAndi Kleen [AGGR_SOCKET] = "socket,cpus", 1452c51fd639SAndi Kleen [AGGR_NONE] = "cpu,", 1453c51fd639SAndi Kleen [AGGR_THREAD] = "comm-pid,", 1454c51fd639SAndi Kleen [AGGR_GLOBAL] = "" 1455c51fd639SAndi Kleen }; 1456c51fd639SAndi Kleen 145741c8ca2aSAndi Kleen static void print_metric_headers(const char *prefix, bool no_indent) 145854b50916SAndi Kleen { 145954b50916SAndi Kleen struct perf_stat_output_ctx out; 146054b50916SAndi Kleen struct perf_evsel *counter; 146154b50916SAndi Kleen struct outstate os = { 146254b50916SAndi Kleen .fh = stat_config.output 146354b50916SAndi Kleen }; 146454b50916SAndi Kleen 146554b50916SAndi Kleen if (prefix) 146654b50916SAndi Kleen fprintf(stat_config.output, "%s", prefix); 146754b50916SAndi Kleen 146841c8ca2aSAndi Kleen if (!csv_output && !no_indent) 146954b50916SAndi Kleen fprintf(stat_config.output, "%*s", 147054b50916SAndi Kleen aggr_header_lens[stat_config.aggr_mode], ""); 1471c51fd639SAndi Kleen if (csv_output) { 1472c51fd639SAndi Kleen if (stat_config.interval) 1473c51fd639SAndi Kleen fputs("time,", stat_config.output); 1474c51fd639SAndi Kleen fputs(aggr_header_csv[stat_config.aggr_mode], 1475c51fd639SAndi Kleen stat_config.output); 1476c51fd639SAndi Kleen } 147754b50916SAndi Kleen 147854b50916SAndi Kleen /* Print metrics headers only */ 1479e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 148054b50916SAndi Kleen os.evsel = counter; 148154b50916SAndi Kleen out.ctx = &os; 148254b50916SAndi Kleen out.print_metric = print_metric_header; 148354b50916SAndi Kleen out.new_line = new_line_metric; 148437932c18SAndi Kleen out.force_header = true; 148554b50916SAndi Kleen os.evsel = counter; 148654b50916SAndi Kleen perf_stat__print_shadow_stats(counter, 0, 148754b50916SAndi Kleen 0, 148854b50916SAndi Kleen &out); 148954b50916SAndi Kleen } 149054b50916SAndi Kleen fputc('\n', stat_config.output); 149154b50916SAndi Kleen } 149254b50916SAndi Kleen 1493d4f63a47SJiri Olsa static void print_interval(char *prefix, struct timespec *ts) 149442202dd5SIngo Molnar { 14955821522eSJiri Olsa FILE *output = stat_config.output; 1496d4f63a47SJiri Olsa static int num_print_interval; 1497d4f63a47SJiri Olsa 1498d4f63a47SJiri Olsa sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, csv_sep); 1499d4f63a47SJiri Olsa 150041c8ca2aSAndi Kleen if (num_print_interval == 0 && !csv_output) { 1501421a50f3SJiri Olsa switch (stat_config.aggr_mode) { 1502d4f63a47SJiri Olsa case AGGR_SOCKET: 150341c8ca2aSAndi Kleen fprintf(output, "# time socket cpus"); 150441c8ca2aSAndi Kleen if (!metric_only) 150541c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 1506d4f63a47SJiri Olsa break; 1507d4f63a47SJiri Olsa case AGGR_CORE: 150841c8ca2aSAndi Kleen fprintf(output, "# time core cpus"); 150941c8ca2aSAndi Kleen if (!metric_only) 151041c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 1511d4f63a47SJiri Olsa break; 1512d4f63a47SJiri Olsa case AGGR_NONE: 151341c8ca2aSAndi Kleen fprintf(output, "# time CPU"); 151441c8ca2aSAndi Kleen if (!metric_only) 151541c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 1516d4f63a47SJiri Olsa break; 151732b8af82SJiri Olsa case AGGR_THREAD: 151841c8ca2aSAndi Kleen fprintf(output, "# time comm-pid"); 151941c8ca2aSAndi Kleen if (!metric_only) 152041c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 152132b8af82SJiri Olsa break; 1522d4f63a47SJiri Olsa case AGGR_GLOBAL: 1523d4f63a47SJiri Olsa default: 152441c8ca2aSAndi Kleen fprintf(output, "# time"); 152541c8ca2aSAndi Kleen if (!metric_only) 152641c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 1527208df99eSJiri Olsa case AGGR_UNSET: 1528208df99eSJiri Olsa break; 1529d4f63a47SJiri Olsa } 1530d4f63a47SJiri Olsa } 1531d4f63a47SJiri Olsa 153241c8ca2aSAndi Kleen if (num_print_interval == 0 && metric_only) 153341c8ca2aSAndi Kleen print_metric_headers(" ", true); 1534d4f63a47SJiri Olsa if (++num_print_interval == 25) 1535d4f63a47SJiri Olsa num_print_interval = 0; 1536d4f63a47SJiri Olsa } 1537d4f63a47SJiri Olsa 1538d4f63a47SJiri Olsa static void print_header(int argc, const char **argv) 1539d4f63a47SJiri Olsa { 15405821522eSJiri Olsa FILE *output = stat_config.output; 154169aad6f1SArnaldo Carvalho de Melo int i; 154242202dd5SIngo Molnar 154386470930SIngo Molnar fflush(stdout); 154486470930SIngo Molnar 1545d7470b6aSStephane Eranian if (!csv_output) { 15464aa9015fSStephane Eranian fprintf(output, "\n"); 15474aa9015fSStephane Eranian fprintf(output, " Performance counter stats for "); 154862d3b617SDavid Ahern if (target.system_wide) 154962d3b617SDavid Ahern fprintf(output, "\'system wide"); 155062d3b617SDavid Ahern else if (target.cpu_list) 155162d3b617SDavid Ahern fprintf(output, "\'CPU(s) %s", target.cpu_list); 1552602ad878SArnaldo Carvalho de Melo else if (!target__has_task(&target)) { 1553ba6039b6SJiri Olsa fprintf(output, "\'%s", argv ? argv[0] : "pipe"); 1554ba6039b6SJiri Olsa for (i = 1; argv && (i < argc); i++) 15554aa9015fSStephane Eranian fprintf(output, " %s", argv[i]); 155620f946b4SNamhyung Kim } else if (target.pid) 155720f946b4SNamhyung Kim fprintf(output, "process id \'%s", target.pid); 1558d6d901c2SZhang, Yanmin else 155920f946b4SNamhyung Kim fprintf(output, "thread id \'%s", target.tid); 156086470930SIngo Molnar 15614aa9015fSStephane Eranian fprintf(output, "\'"); 156242202dd5SIngo Molnar if (run_count > 1) 15634aa9015fSStephane Eranian fprintf(output, " (%d runs)", run_count); 15644aa9015fSStephane Eranian fprintf(output, ":\n\n"); 1565d7470b6aSStephane Eranian } 1566f5b4a9c3SStephane Eranian } 156786470930SIngo Molnar 1568d4f63a47SJiri Olsa static void print_footer(void) 1569d4f63a47SJiri Olsa { 15705821522eSJiri Olsa FILE *output = stat_config.output; 15715821522eSJiri Olsa 1572c3305257SIngo Molnar if (!null_run) 15734aa9015fSStephane Eranian fprintf(output, "\n"); 15744aa9015fSStephane Eranian fprintf(output, " %17.9f seconds time elapsed", 1575310ebb93SArnaldo Carvalho de Melo avg_stats(&walltime_nsecs_stats) / NSEC_PER_SEC); 1576566747e6SIngo Molnar if (run_count > 1) { 15774aa9015fSStephane Eranian fprintf(output, " "); 1578f99844cbSIngo Molnar print_noise_pct(stddev_stats(&walltime_nsecs_stats), 1579506d4bc8SPeter Zijlstra avg_stats(&walltime_nsecs_stats)); 1580566747e6SIngo Molnar } 15814aa9015fSStephane Eranian fprintf(output, "\n\n"); 158202d492e5SBorislav Petkov 158302d492e5SBorislav Petkov if (print_free_counters_hint) 158402d492e5SBorislav Petkov fprintf(output, 158502d492e5SBorislav Petkov "Some events weren't counted. Try disabling the NMI watchdog:\n" 158602d492e5SBorislav Petkov " echo 0 > /proc/sys/kernel/nmi_watchdog\n" 158702d492e5SBorislav Petkov " perf stat ...\n" 158802d492e5SBorislav Petkov " echo 1 > /proc/sys/kernel/nmi_watchdog\n"); 158986470930SIngo Molnar } 1590d4f63a47SJiri Olsa 1591d4f63a47SJiri Olsa static void print_counters(struct timespec *ts, int argc, const char **argv) 1592d4f63a47SJiri Olsa { 1593ec0d3d1fSJiri Olsa int interval = stat_config.interval; 1594d4f63a47SJiri Olsa struct perf_evsel *counter; 1595d4f63a47SJiri Olsa char buf[64], *prefix = NULL; 1596d4f63a47SJiri Olsa 1597664c98d4SJiri Olsa /* Do not print anything if we record to the pipe. */ 1598664c98d4SJiri Olsa if (STAT_RECORD && perf_stat.file.is_pipe) 1599664c98d4SJiri Olsa return; 1600664c98d4SJiri Olsa 1601d4f63a47SJiri Olsa if (interval) 1602d4f63a47SJiri Olsa print_interval(prefix = buf, ts); 1603d4f63a47SJiri Olsa else 1604d4f63a47SJiri Olsa print_header(argc, argv); 1605d4f63a47SJiri Olsa 160654b50916SAndi Kleen if (metric_only) { 160754b50916SAndi Kleen static int num_print_iv; 160854b50916SAndi Kleen 160941c8ca2aSAndi Kleen if (num_print_iv == 0 && !interval) 161041c8ca2aSAndi Kleen print_metric_headers(prefix, false); 161154b50916SAndi Kleen if (num_print_iv++ == 25) 161254b50916SAndi Kleen num_print_iv = 0; 161354b50916SAndi Kleen if (stat_config.aggr_mode == AGGR_GLOBAL && prefix) 161454b50916SAndi Kleen fprintf(stat_config.output, "%s", prefix); 161554b50916SAndi Kleen } 161654b50916SAndi Kleen 1617421a50f3SJiri Olsa switch (stat_config.aggr_mode) { 1618d4f63a47SJiri Olsa case AGGR_CORE: 1619d4f63a47SJiri Olsa case AGGR_SOCKET: 1620d4f63a47SJiri Olsa print_aggr(prefix); 1621d4f63a47SJiri Olsa break; 162232b8af82SJiri Olsa case AGGR_THREAD: 1623e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) 162432b8af82SJiri Olsa print_aggr_thread(counter, prefix); 162532b8af82SJiri Olsa break; 1626d4f63a47SJiri Olsa case AGGR_GLOBAL: 1627e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) 1628d4f63a47SJiri Olsa print_counter_aggr(counter, prefix); 162954b50916SAndi Kleen if (metric_only) 163054b50916SAndi Kleen fputc('\n', stat_config.output); 1631d4f63a47SJiri Olsa break; 1632d4f63a47SJiri Olsa case AGGR_NONE: 1633206cab65SAndi Kleen if (metric_only) 1634206cab65SAndi Kleen print_no_aggr_metric(prefix); 1635206cab65SAndi Kleen else { 1636e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) 1637d4f63a47SJiri Olsa print_counter(counter, prefix); 1638206cab65SAndi Kleen } 1639d4f63a47SJiri Olsa break; 1640208df99eSJiri Olsa case AGGR_UNSET: 1641d4f63a47SJiri Olsa default: 1642d4f63a47SJiri Olsa break; 1643d4f63a47SJiri Olsa } 1644d4f63a47SJiri Olsa 1645d4f63a47SJiri Olsa if (!interval && !csv_output) 1646d4f63a47SJiri Olsa print_footer(); 1647d4f63a47SJiri Olsa 16485821522eSJiri Olsa fflush(stat_config.output); 1649d7470b6aSStephane Eranian } 165086470930SIngo Molnar 1651f7b7c26eSPeter Zijlstra static volatile int signr = -1; 1652f7b7c26eSPeter Zijlstra 165386470930SIngo Molnar static void skip_signal(int signo) 165486470930SIngo Molnar { 1655ec0d3d1fSJiri Olsa if ((child_pid == -1) || stat_config.interval) 165660666c63SLiming Wang done = 1; 165760666c63SLiming Wang 1658f7b7c26eSPeter Zijlstra signr = signo; 1659d07f0b12SStephane Eranian /* 1660d07f0b12SStephane Eranian * render child_pid harmless 1661d07f0b12SStephane Eranian * won't send SIGTERM to a random 1662d07f0b12SStephane Eranian * process in case of race condition 1663d07f0b12SStephane Eranian * and fast PID recycling 1664d07f0b12SStephane Eranian */ 1665d07f0b12SStephane Eranian child_pid = -1; 1666f7b7c26eSPeter Zijlstra } 1667f7b7c26eSPeter Zijlstra 1668f7b7c26eSPeter Zijlstra static void sig_atexit(void) 1669f7b7c26eSPeter Zijlstra { 1670d07f0b12SStephane Eranian sigset_t set, oset; 1671d07f0b12SStephane Eranian 1672d07f0b12SStephane Eranian /* 1673d07f0b12SStephane Eranian * avoid race condition with SIGCHLD handler 1674d07f0b12SStephane Eranian * in skip_signal() which is modifying child_pid 1675d07f0b12SStephane Eranian * goal is to avoid send SIGTERM to a random 1676d07f0b12SStephane Eranian * process 1677d07f0b12SStephane Eranian */ 1678d07f0b12SStephane Eranian sigemptyset(&set); 1679d07f0b12SStephane Eranian sigaddset(&set, SIGCHLD); 1680d07f0b12SStephane Eranian sigprocmask(SIG_BLOCK, &set, &oset); 1681d07f0b12SStephane Eranian 1682933da83aSChris Wilson if (child_pid != -1) 1683933da83aSChris Wilson kill(child_pid, SIGTERM); 1684933da83aSChris Wilson 1685d07f0b12SStephane Eranian sigprocmask(SIG_SETMASK, &oset, NULL); 1686d07f0b12SStephane Eranian 1687f7b7c26eSPeter Zijlstra if (signr == -1) 1688f7b7c26eSPeter Zijlstra return; 1689f7b7c26eSPeter Zijlstra 1690f7b7c26eSPeter Zijlstra signal(signr, SIG_DFL); 1691f7b7c26eSPeter Zijlstra kill(getpid(), signr); 169286470930SIngo Molnar } 169386470930SIngo Molnar 16941d037ca1SIrina Tirdea static int stat__set_big_num(const struct option *opt __maybe_unused, 16951d037ca1SIrina Tirdea const char *s __maybe_unused, int unset) 1696d7470b6aSStephane Eranian { 1697d7470b6aSStephane Eranian big_num_opt = unset ? 0 : 1; 1698d7470b6aSStephane Eranian return 0; 1699d7470b6aSStephane Eranian } 1700d7470b6aSStephane Eranian 170144b1e60aSAndi Kleen static int enable_metric_only(const struct option *opt __maybe_unused, 170244b1e60aSAndi Kleen const char *s __maybe_unused, int unset) 170344b1e60aSAndi Kleen { 170444b1e60aSAndi Kleen force_metric_only = true; 170544b1e60aSAndi Kleen metric_only = !unset; 170644b1e60aSAndi Kleen return 0; 170744b1e60aSAndi Kleen } 170844b1e60aSAndi Kleen 1709e0547311SJiri Olsa static const struct option stat_options[] = { 1710e0547311SJiri Olsa OPT_BOOLEAN('T', "transaction", &transaction_run, 1711e0547311SJiri Olsa "hardware transaction statistics"), 1712e0547311SJiri Olsa OPT_CALLBACK('e', "event", &evsel_list, "event", 1713e0547311SJiri Olsa "event selector. use 'perf list' to list available events", 1714e0547311SJiri Olsa parse_events_option), 1715e0547311SJiri Olsa OPT_CALLBACK(0, "filter", &evsel_list, "filter", 1716e0547311SJiri Olsa "event filter", parse_filter), 1717e0547311SJiri Olsa OPT_BOOLEAN('i', "no-inherit", &no_inherit, 1718e0547311SJiri Olsa "child tasks do not inherit counters"), 1719e0547311SJiri Olsa OPT_STRING('p', "pid", &target.pid, "pid", 1720e0547311SJiri Olsa "stat events on existing process id"), 1721e0547311SJiri Olsa OPT_STRING('t', "tid", &target.tid, "tid", 1722e0547311SJiri Olsa "stat events on existing thread id"), 1723e0547311SJiri Olsa OPT_BOOLEAN('a', "all-cpus", &target.system_wide, 1724e0547311SJiri Olsa "system-wide collection from all CPUs"), 1725e0547311SJiri Olsa OPT_BOOLEAN('g', "group", &group, 1726e0547311SJiri Olsa "put the counters into a counter group"), 1727e0547311SJiri Olsa OPT_BOOLEAN('c', "scale", &stat_config.scale, "scale/normalize counters"), 1728e0547311SJiri Olsa OPT_INCR('v', "verbose", &verbose, 1729e0547311SJiri Olsa "be more verbose (show counter open errors, etc)"), 1730e0547311SJiri Olsa OPT_INTEGER('r', "repeat", &run_count, 1731e0547311SJiri Olsa "repeat command and print average + stddev (max: 100, forever: 0)"), 1732e0547311SJiri Olsa OPT_BOOLEAN('n', "null", &null_run, 1733e0547311SJiri Olsa "null run - dont start any counters"), 1734e0547311SJiri Olsa OPT_INCR('d', "detailed", &detailed_run, 1735e0547311SJiri Olsa "detailed run - start a lot of events"), 1736e0547311SJiri Olsa OPT_BOOLEAN('S', "sync", &sync_run, 1737e0547311SJiri Olsa "call sync() before starting a run"), 1738e0547311SJiri Olsa OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 1739e0547311SJiri Olsa "print large numbers with thousands\' separators", 1740e0547311SJiri Olsa stat__set_big_num), 1741e0547311SJiri Olsa OPT_STRING('C', "cpu", &target.cpu_list, "cpu", 1742e0547311SJiri Olsa "list of cpus to monitor in system-wide"), 1743e0547311SJiri Olsa OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode, 1744e0547311SJiri Olsa "disable CPU count aggregation", AGGR_NONE), 1745430daf2dSAndi Kleen OPT_BOOLEAN(0, "no-merge", &no_merge, "Do not merge identical named events"), 1746e0547311SJiri Olsa OPT_STRING('x', "field-separator", &csv_sep, "separator", 1747e0547311SJiri Olsa "print counts with custom separator"), 1748e0547311SJiri Olsa OPT_CALLBACK('G', "cgroup", &evsel_list, "name", 1749e0547311SJiri Olsa "monitor event in cgroup name only", parse_cgroups), 1750e0547311SJiri Olsa OPT_STRING('o', "output", &output_name, "file", "output file name"), 1751e0547311SJiri Olsa OPT_BOOLEAN(0, "append", &append_file, "append to the output file"), 1752e0547311SJiri Olsa OPT_INTEGER(0, "log-fd", &output_fd, 1753e0547311SJiri Olsa "log output to fd, instead of stderr"), 1754e0547311SJiri Olsa OPT_STRING(0, "pre", &pre_cmd, "command", 1755e0547311SJiri Olsa "command to run prior to the measured command"), 1756e0547311SJiri Olsa OPT_STRING(0, "post", &post_cmd, "command", 1757e0547311SJiri Olsa "command to run after to the measured command"), 1758e0547311SJiri Olsa OPT_UINTEGER('I', "interval-print", &stat_config.interval, 1759e0547311SJiri Olsa "print counts at regular interval in ms (>= 10)"), 1760e0547311SJiri Olsa OPT_SET_UINT(0, "per-socket", &stat_config.aggr_mode, 1761e0547311SJiri Olsa "aggregate counts per processor socket", AGGR_SOCKET), 1762e0547311SJiri Olsa OPT_SET_UINT(0, "per-core", &stat_config.aggr_mode, 1763e0547311SJiri Olsa "aggregate counts per physical processor core", AGGR_CORE), 1764e0547311SJiri Olsa OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode, 1765e0547311SJiri Olsa "aggregate counts per thread", AGGR_THREAD), 1766e0547311SJiri Olsa OPT_UINTEGER('D', "delay", &initial_delay, 1767e0547311SJiri Olsa "ms to wait before starting measurement after program start"), 176844b1e60aSAndi Kleen OPT_CALLBACK_NOOPT(0, "metric-only", &metric_only, NULL, 176944b1e60aSAndi Kleen "Only print computed metrics. No raw values", enable_metric_only), 177044b1e60aSAndi Kleen OPT_BOOLEAN(0, "topdown", &topdown_run, 177144b1e60aSAndi Kleen "measure topdown level 1 statistics"), 1772e0547311SJiri Olsa OPT_END() 1773e0547311SJiri Olsa }; 1774e0547311SJiri Olsa 17751fe7a300SJiri Olsa static int perf_stat__get_socket(struct cpu_map *map, int cpu) 17761fe7a300SJiri Olsa { 17771fe7a300SJiri Olsa return cpu_map__get_socket(map, cpu, NULL); 17781fe7a300SJiri Olsa } 17791fe7a300SJiri Olsa 17801fe7a300SJiri Olsa static int perf_stat__get_core(struct cpu_map *map, int cpu) 17811fe7a300SJiri Olsa { 17821fe7a300SJiri Olsa return cpu_map__get_core(map, cpu, NULL); 17831fe7a300SJiri Olsa } 17841fe7a300SJiri Olsa 17851e5a2931SJiri Olsa static int cpu_map__get_max(struct cpu_map *map) 17861e5a2931SJiri Olsa { 17871e5a2931SJiri Olsa int i, max = -1; 17881e5a2931SJiri Olsa 17891e5a2931SJiri Olsa for (i = 0; i < map->nr; i++) { 17901e5a2931SJiri Olsa if (map->map[i] > max) 17911e5a2931SJiri Olsa max = map->map[i]; 17921e5a2931SJiri Olsa } 17931e5a2931SJiri Olsa 17941e5a2931SJiri Olsa return max; 17951e5a2931SJiri Olsa } 17961e5a2931SJiri Olsa 17971e5a2931SJiri Olsa static struct cpu_map *cpus_aggr_map; 17981e5a2931SJiri Olsa 17991e5a2931SJiri Olsa static int perf_stat__get_aggr(aggr_get_id_t get_id, struct cpu_map *map, int idx) 18001e5a2931SJiri Olsa { 18011e5a2931SJiri Olsa int cpu; 18021e5a2931SJiri Olsa 18031e5a2931SJiri Olsa if (idx >= map->nr) 18041e5a2931SJiri Olsa return -1; 18051e5a2931SJiri Olsa 18061e5a2931SJiri Olsa cpu = map->map[idx]; 18071e5a2931SJiri Olsa 18081e5a2931SJiri Olsa if (cpus_aggr_map->map[cpu] == -1) 18091e5a2931SJiri Olsa cpus_aggr_map->map[cpu] = get_id(map, idx); 18101e5a2931SJiri Olsa 18111e5a2931SJiri Olsa return cpus_aggr_map->map[cpu]; 18121e5a2931SJiri Olsa } 18131e5a2931SJiri Olsa 18141e5a2931SJiri Olsa static int perf_stat__get_socket_cached(struct cpu_map *map, int idx) 18151e5a2931SJiri Olsa { 18161e5a2931SJiri Olsa return perf_stat__get_aggr(perf_stat__get_socket, map, idx); 18171e5a2931SJiri Olsa } 18181e5a2931SJiri Olsa 18191e5a2931SJiri Olsa static int perf_stat__get_core_cached(struct cpu_map *map, int idx) 18201e5a2931SJiri Olsa { 18211e5a2931SJiri Olsa return perf_stat__get_aggr(perf_stat__get_core, map, idx); 18221e5a2931SJiri Olsa } 18231e5a2931SJiri Olsa 182486ee6e18SStephane Eranian static int perf_stat_init_aggr_mode(void) 182586ee6e18SStephane Eranian { 18261e5a2931SJiri Olsa int nr; 18271e5a2931SJiri Olsa 1828421a50f3SJiri Olsa switch (stat_config.aggr_mode) { 182986ee6e18SStephane Eranian case AGGR_SOCKET: 183086ee6e18SStephane Eranian if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) { 183186ee6e18SStephane Eranian perror("cannot build socket map"); 183286ee6e18SStephane Eranian return -1; 183386ee6e18SStephane Eranian } 18341e5a2931SJiri Olsa aggr_get_id = perf_stat__get_socket_cached; 183586ee6e18SStephane Eranian break; 183612c08a9fSStephane Eranian case AGGR_CORE: 183712c08a9fSStephane Eranian if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) { 183812c08a9fSStephane Eranian perror("cannot build core map"); 183912c08a9fSStephane Eranian return -1; 184012c08a9fSStephane Eranian } 18411e5a2931SJiri Olsa aggr_get_id = perf_stat__get_core_cached; 184212c08a9fSStephane Eranian break; 184386ee6e18SStephane Eranian case AGGR_NONE: 184486ee6e18SStephane Eranian case AGGR_GLOBAL: 184532b8af82SJiri Olsa case AGGR_THREAD: 1846208df99eSJiri Olsa case AGGR_UNSET: 184786ee6e18SStephane Eranian default: 184886ee6e18SStephane Eranian break; 184986ee6e18SStephane Eranian } 18501e5a2931SJiri Olsa 18511e5a2931SJiri Olsa /* 18521e5a2931SJiri Olsa * The evsel_list->cpus is the base we operate on, 18531e5a2931SJiri Olsa * taking the highest cpu number to be the size of 18541e5a2931SJiri Olsa * the aggregation translate cpumap. 18551e5a2931SJiri Olsa */ 18561e5a2931SJiri Olsa nr = cpu_map__get_max(evsel_list->cpus); 18571e5a2931SJiri Olsa cpus_aggr_map = cpu_map__empty_new(nr + 1); 18581e5a2931SJiri Olsa return cpus_aggr_map ? 0 : -ENOMEM; 185986ee6e18SStephane Eranian } 186086ee6e18SStephane Eranian 1861544c2ae7SMasami Hiramatsu static void perf_stat__exit_aggr_mode(void) 1862544c2ae7SMasami Hiramatsu { 1863544c2ae7SMasami Hiramatsu cpu_map__put(aggr_map); 1864544c2ae7SMasami Hiramatsu cpu_map__put(cpus_aggr_map); 1865544c2ae7SMasami Hiramatsu aggr_map = NULL; 1866544c2ae7SMasami Hiramatsu cpus_aggr_map = NULL; 1867544c2ae7SMasami Hiramatsu } 1868544c2ae7SMasami Hiramatsu 186968d702f7SJiri Olsa static inline int perf_env__get_cpu(struct perf_env *env, struct cpu_map *map, int idx) 187068d702f7SJiri Olsa { 187168d702f7SJiri Olsa int cpu; 187268d702f7SJiri Olsa 187368d702f7SJiri Olsa if (idx > map->nr) 187468d702f7SJiri Olsa return -1; 187568d702f7SJiri Olsa 187668d702f7SJiri Olsa cpu = map->map[idx]; 187768d702f7SJiri Olsa 1878da8a58b5SJan Stancek if (cpu >= env->nr_cpus_avail) 187968d702f7SJiri Olsa return -1; 188068d702f7SJiri Olsa 188168d702f7SJiri Olsa return cpu; 188268d702f7SJiri Olsa } 188368d702f7SJiri Olsa 188468d702f7SJiri Olsa static int perf_env__get_socket(struct cpu_map *map, int idx, void *data) 188568d702f7SJiri Olsa { 188668d702f7SJiri Olsa struct perf_env *env = data; 188768d702f7SJiri Olsa int cpu = perf_env__get_cpu(env, map, idx); 188868d702f7SJiri Olsa 188968d702f7SJiri Olsa return cpu == -1 ? -1 : env->cpu[cpu].socket_id; 189068d702f7SJiri Olsa } 189168d702f7SJiri Olsa 189268d702f7SJiri Olsa static int perf_env__get_core(struct cpu_map *map, int idx, void *data) 189368d702f7SJiri Olsa { 189468d702f7SJiri Olsa struct perf_env *env = data; 189568d702f7SJiri Olsa int core = -1, cpu = perf_env__get_cpu(env, map, idx); 189668d702f7SJiri Olsa 189768d702f7SJiri Olsa if (cpu != -1) { 189868d702f7SJiri Olsa int socket_id = env->cpu[cpu].socket_id; 189968d702f7SJiri Olsa 190068d702f7SJiri Olsa /* 190168d702f7SJiri Olsa * Encode socket in upper 16 bits 190268d702f7SJiri Olsa * core_id is relative to socket, and 190368d702f7SJiri Olsa * we need a global id. So we combine 190468d702f7SJiri Olsa * socket + core id. 190568d702f7SJiri Olsa */ 190668d702f7SJiri Olsa core = (socket_id << 16) | (env->cpu[cpu].core_id & 0xffff); 190768d702f7SJiri Olsa } 190868d702f7SJiri Olsa 190968d702f7SJiri Olsa return core; 191068d702f7SJiri Olsa } 191168d702f7SJiri Olsa 191268d702f7SJiri Olsa static int perf_env__build_socket_map(struct perf_env *env, struct cpu_map *cpus, 191368d702f7SJiri Olsa struct cpu_map **sockp) 191468d702f7SJiri Olsa { 191568d702f7SJiri Olsa return cpu_map__build_map(cpus, sockp, perf_env__get_socket, env); 191668d702f7SJiri Olsa } 191768d702f7SJiri Olsa 191868d702f7SJiri Olsa static int perf_env__build_core_map(struct perf_env *env, struct cpu_map *cpus, 191968d702f7SJiri Olsa struct cpu_map **corep) 192068d702f7SJiri Olsa { 192168d702f7SJiri Olsa return cpu_map__build_map(cpus, corep, perf_env__get_core, env); 192268d702f7SJiri Olsa } 192368d702f7SJiri Olsa 192468d702f7SJiri Olsa static int perf_stat__get_socket_file(struct cpu_map *map, int idx) 192568d702f7SJiri Olsa { 192668d702f7SJiri Olsa return perf_env__get_socket(map, idx, &perf_stat.session->header.env); 192768d702f7SJiri Olsa } 192868d702f7SJiri Olsa 192968d702f7SJiri Olsa static int perf_stat__get_core_file(struct cpu_map *map, int idx) 193068d702f7SJiri Olsa { 193168d702f7SJiri Olsa return perf_env__get_core(map, idx, &perf_stat.session->header.env); 193268d702f7SJiri Olsa } 193368d702f7SJiri Olsa 193468d702f7SJiri Olsa static int perf_stat_init_aggr_mode_file(struct perf_stat *st) 193568d702f7SJiri Olsa { 193668d702f7SJiri Olsa struct perf_env *env = &st->session->header.env; 193768d702f7SJiri Olsa 193868d702f7SJiri Olsa switch (stat_config.aggr_mode) { 193968d702f7SJiri Olsa case AGGR_SOCKET: 194068d702f7SJiri Olsa if (perf_env__build_socket_map(env, evsel_list->cpus, &aggr_map)) { 194168d702f7SJiri Olsa perror("cannot build socket map"); 194268d702f7SJiri Olsa return -1; 194368d702f7SJiri Olsa } 194468d702f7SJiri Olsa aggr_get_id = perf_stat__get_socket_file; 194568d702f7SJiri Olsa break; 194668d702f7SJiri Olsa case AGGR_CORE: 194768d702f7SJiri Olsa if (perf_env__build_core_map(env, evsel_list->cpus, &aggr_map)) { 194868d702f7SJiri Olsa perror("cannot build core map"); 194968d702f7SJiri Olsa return -1; 195068d702f7SJiri Olsa } 195168d702f7SJiri Olsa aggr_get_id = perf_stat__get_core_file; 195268d702f7SJiri Olsa break; 195368d702f7SJiri Olsa case AGGR_NONE: 195468d702f7SJiri Olsa case AGGR_GLOBAL: 195568d702f7SJiri Olsa case AGGR_THREAD: 195668d702f7SJiri Olsa case AGGR_UNSET: 195768d702f7SJiri Olsa default: 195868d702f7SJiri Olsa break; 195968d702f7SJiri Olsa } 196068d702f7SJiri Olsa 196168d702f7SJiri Olsa return 0; 196268d702f7SJiri Olsa } 196368d702f7SJiri Olsa 196444b1e60aSAndi Kleen static int topdown_filter_events(const char **attr, char **str, bool use_group) 196544b1e60aSAndi Kleen { 196644b1e60aSAndi Kleen int off = 0; 196744b1e60aSAndi Kleen int i; 196844b1e60aSAndi Kleen int len = 0; 196944b1e60aSAndi Kleen char *s; 197044b1e60aSAndi Kleen 197144b1e60aSAndi Kleen for (i = 0; attr[i]; i++) { 197244b1e60aSAndi Kleen if (pmu_have_event("cpu", attr[i])) { 197344b1e60aSAndi Kleen len += strlen(attr[i]) + 1; 197444b1e60aSAndi Kleen attr[i - off] = attr[i]; 197544b1e60aSAndi Kleen } else 197644b1e60aSAndi Kleen off++; 197744b1e60aSAndi Kleen } 197844b1e60aSAndi Kleen attr[i - off] = NULL; 197944b1e60aSAndi Kleen 198044b1e60aSAndi Kleen *str = malloc(len + 1 + 2); 198144b1e60aSAndi Kleen if (!*str) 198244b1e60aSAndi Kleen return -1; 198344b1e60aSAndi Kleen s = *str; 198444b1e60aSAndi Kleen if (i - off == 0) { 198544b1e60aSAndi Kleen *s = 0; 198644b1e60aSAndi Kleen return 0; 198744b1e60aSAndi Kleen } 198844b1e60aSAndi Kleen if (use_group) 198944b1e60aSAndi Kleen *s++ = '{'; 199044b1e60aSAndi Kleen for (i = 0; attr[i]; i++) { 199144b1e60aSAndi Kleen strcpy(s, attr[i]); 199244b1e60aSAndi Kleen s += strlen(s); 199344b1e60aSAndi Kleen *s++ = ','; 199444b1e60aSAndi Kleen } 199544b1e60aSAndi Kleen if (use_group) { 199644b1e60aSAndi Kleen s[-1] = '}'; 199744b1e60aSAndi Kleen *s = 0; 199844b1e60aSAndi Kleen } else 199944b1e60aSAndi Kleen s[-1] = 0; 200044b1e60aSAndi Kleen return 0; 200144b1e60aSAndi Kleen } 200244b1e60aSAndi Kleen 200344b1e60aSAndi Kleen __weak bool arch_topdown_check_group(bool *warn) 200444b1e60aSAndi Kleen { 200544b1e60aSAndi Kleen *warn = false; 200644b1e60aSAndi Kleen return false; 200744b1e60aSAndi Kleen } 200844b1e60aSAndi Kleen 200944b1e60aSAndi Kleen __weak void arch_topdown_group_warn(void) 201044b1e60aSAndi Kleen { 201144b1e60aSAndi Kleen } 201244b1e60aSAndi Kleen 20132cba3ffbSIngo Molnar /* 20142cba3ffbSIngo Molnar * Add default attributes, if there were no attributes specified or 20152cba3ffbSIngo Molnar * if -d/--detailed, -d -d or -d -d -d is used: 20162cba3ffbSIngo Molnar */ 20172cba3ffbSIngo Molnar static int add_default_attributes(void) 20182cba3ffbSIngo Molnar { 201944b1e60aSAndi Kleen int err; 20209dec4473SAndi Kleen struct perf_event_attr default_attrs0[] = { 2021b070a547SArnaldo Carvalho de Melo 2022b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK }, 2023b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES }, 2024b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS }, 2025b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS }, 2026b070a547SArnaldo Carvalho de Melo 2027b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES }, 20289dec4473SAndi Kleen }; 20299dec4473SAndi Kleen struct perf_event_attr frontend_attrs[] = { 2030b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND }, 20319dec4473SAndi Kleen }; 20329dec4473SAndi Kleen struct perf_event_attr backend_attrs[] = { 2033b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND }, 20349dec4473SAndi Kleen }; 20359dec4473SAndi Kleen struct perf_event_attr default_attrs1[] = { 2036b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS }, 2037b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS }, 2038b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES }, 2039b070a547SArnaldo Carvalho de Melo 2040b070a547SArnaldo Carvalho de Melo }; 2041b070a547SArnaldo Carvalho de Melo 2042b070a547SArnaldo Carvalho de Melo /* 2043b070a547SArnaldo Carvalho de Melo * Detailed stats (-d), covering the L1 and last level data caches: 2044b070a547SArnaldo Carvalho de Melo */ 2045b070a547SArnaldo Carvalho de Melo struct perf_event_attr detailed_attrs[] = { 2046b070a547SArnaldo Carvalho de Melo 2047b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2048b070a547SArnaldo Carvalho de Melo .config = 2049b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 2050b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2051b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2052b070a547SArnaldo Carvalho de Melo 2053b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2054b070a547SArnaldo Carvalho de Melo .config = 2055b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 2056b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2057b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2058b070a547SArnaldo Carvalho de Melo 2059b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2060b070a547SArnaldo Carvalho de Melo .config = 2061b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 2062b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2063b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2064b070a547SArnaldo Carvalho de Melo 2065b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2066b070a547SArnaldo Carvalho de Melo .config = 2067b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 2068b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2069b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2070b070a547SArnaldo Carvalho de Melo }; 2071b070a547SArnaldo Carvalho de Melo 2072b070a547SArnaldo Carvalho de Melo /* 2073b070a547SArnaldo Carvalho de Melo * Very detailed stats (-d -d), covering the instruction cache and the TLB caches: 2074b070a547SArnaldo Carvalho de Melo */ 2075b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_detailed_attrs[] = { 2076b070a547SArnaldo Carvalho de Melo 2077b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2078b070a547SArnaldo Carvalho de Melo .config = 2079b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 2080b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2081b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2082b070a547SArnaldo Carvalho de Melo 2083b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2084b070a547SArnaldo Carvalho de Melo .config = 2085b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 2086b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2087b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2088b070a547SArnaldo Carvalho de Melo 2089b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2090b070a547SArnaldo Carvalho de Melo .config = 2091b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 2092b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2093b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2094b070a547SArnaldo Carvalho de Melo 2095b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2096b070a547SArnaldo Carvalho de Melo .config = 2097b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 2098b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2099b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2100b070a547SArnaldo Carvalho de Melo 2101b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2102b070a547SArnaldo Carvalho de Melo .config = 2103b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 2104b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2105b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2106b070a547SArnaldo Carvalho de Melo 2107b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2108b070a547SArnaldo Carvalho de Melo .config = 2109b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 2110b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2111b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2112b070a547SArnaldo Carvalho de Melo 2113b070a547SArnaldo Carvalho de Melo }; 2114b070a547SArnaldo Carvalho de Melo 2115b070a547SArnaldo Carvalho de Melo /* 2116b070a547SArnaldo Carvalho de Melo * Very, very detailed stats (-d -d -d), adding prefetch events: 2117b070a547SArnaldo Carvalho de Melo */ 2118b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_very_detailed_attrs[] = { 2119b070a547SArnaldo Carvalho de Melo 2120b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2121b070a547SArnaldo Carvalho de Melo .config = 2122b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 2123b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 2124b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2125b070a547SArnaldo Carvalho de Melo 2126b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2127b070a547SArnaldo Carvalho de Melo .config = 2128b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 2129b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 2130b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2131b070a547SArnaldo Carvalho de Melo }; 2132b070a547SArnaldo Carvalho de Melo 21332cba3ffbSIngo Molnar /* Set attrs if no event is selected and !null_run: */ 21342cba3ffbSIngo Molnar if (null_run) 21352cba3ffbSIngo Molnar return 0; 21362cba3ffbSIngo Molnar 21374cabc3d1SAndi Kleen if (transaction_run) { 21384cabc3d1SAndi Kleen if (pmu_have_event("cpu", "cycles-ct") && 21394cabc3d1SAndi Kleen pmu_have_event("cpu", "el-start")) 2140a454742cSJiri Olsa err = parse_events(evsel_list, transaction_attrs, NULL); 21414cabc3d1SAndi Kleen else 2142a454742cSJiri Olsa err = parse_events(evsel_list, transaction_limited_attrs, NULL); 2143a454742cSJiri Olsa if (err) { 21444cabc3d1SAndi Kleen fprintf(stderr, "Cannot set up transaction events\n"); 21454cabc3d1SAndi Kleen return -1; 21464cabc3d1SAndi Kleen } 21474cabc3d1SAndi Kleen return 0; 21484cabc3d1SAndi Kleen } 21494cabc3d1SAndi Kleen 215044b1e60aSAndi Kleen if (topdown_run) { 215144b1e60aSAndi Kleen char *str = NULL; 215244b1e60aSAndi Kleen bool warn = false; 215344b1e60aSAndi Kleen 215444b1e60aSAndi Kleen if (stat_config.aggr_mode != AGGR_GLOBAL && 215544b1e60aSAndi Kleen stat_config.aggr_mode != AGGR_CORE) { 215644b1e60aSAndi Kleen pr_err("top down event configuration requires --per-core mode\n"); 215744b1e60aSAndi Kleen return -1; 215844b1e60aSAndi Kleen } 215944b1e60aSAndi Kleen stat_config.aggr_mode = AGGR_CORE; 216044b1e60aSAndi Kleen if (nr_cgroups || !target__has_cpu(&target)) { 216144b1e60aSAndi Kleen pr_err("top down event configuration requires system-wide mode (-a)\n"); 216244b1e60aSAndi Kleen return -1; 216344b1e60aSAndi Kleen } 216444b1e60aSAndi Kleen 216544b1e60aSAndi Kleen if (!force_metric_only) 216644b1e60aSAndi Kleen metric_only = true; 216744b1e60aSAndi Kleen if (topdown_filter_events(topdown_attrs, &str, 216844b1e60aSAndi Kleen arch_topdown_check_group(&warn)) < 0) { 216944b1e60aSAndi Kleen pr_err("Out of memory\n"); 217044b1e60aSAndi Kleen return -1; 217144b1e60aSAndi Kleen } 217244b1e60aSAndi Kleen if (topdown_attrs[0] && str) { 217344b1e60aSAndi Kleen if (warn) 217444b1e60aSAndi Kleen arch_topdown_group_warn(); 217544b1e60aSAndi Kleen err = parse_events(evsel_list, str, NULL); 217644b1e60aSAndi Kleen if (err) { 217744b1e60aSAndi Kleen fprintf(stderr, 217844b1e60aSAndi Kleen "Cannot set up top down events %s: %d\n", 217944b1e60aSAndi Kleen str, err); 218044b1e60aSAndi Kleen free(str); 218144b1e60aSAndi Kleen return -1; 218244b1e60aSAndi Kleen } 218344b1e60aSAndi Kleen } else { 218444b1e60aSAndi Kleen fprintf(stderr, "System does not support topdown\n"); 218544b1e60aSAndi Kleen return -1; 218644b1e60aSAndi Kleen } 218744b1e60aSAndi Kleen free(str); 218844b1e60aSAndi Kleen } 218944b1e60aSAndi Kleen 21902cba3ffbSIngo Molnar if (!evsel_list->nr_entries) { 2191a1f3d567SNamhyung Kim if (target__has_cpu(&target)) 2192a1f3d567SNamhyung Kim default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK; 2193a1f3d567SNamhyung Kim 21949dec4473SAndi Kleen if (perf_evlist__add_default_attrs(evsel_list, default_attrs0) < 0) 21959dec4473SAndi Kleen return -1; 21969dec4473SAndi Kleen if (pmu_have_event("cpu", "stalled-cycles-frontend")) { 21979dec4473SAndi Kleen if (perf_evlist__add_default_attrs(evsel_list, 21989dec4473SAndi Kleen frontend_attrs) < 0) 21999dec4473SAndi Kleen return -1; 22009dec4473SAndi Kleen } 22019dec4473SAndi Kleen if (pmu_have_event("cpu", "stalled-cycles-backend")) { 22029dec4473SAndi Kleen if (perf_evlist__add_default_attrs(evsel_list, 22039dec4473SAndi Kleen backend_attrs) < 0) 22049dec4473SAndi Kleen return -1; 22059dec4473SAndi Kleen } 22069dec4473SAndi Kleen if (perf_evlist__add_default_attrs(evsel_list, default_attrs1) < 0) 22072cba3ffbSIngo Molnar return -1; 22082cba3ffbSIngo Molnar } 22092cba3ffbSIngo Molnar 22102cba3ffbSIngo Molnar /* Detailed events get appended to the event list: */ 22112cba3ffbSIngo Molnar 22122cba3ffbSIngo Molnar if (detailed_run < 1) 22132cba3ffbSIngo Molnar return 0; 22142cba3ffbSIngo Molnar 22152cba3ffbSIngo Molnar /* Append detailed run extra attributes: */ 221679695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0) 22172cba3ffbSIngo Molnar return -1; 22182cba3ffbSIngo Molnar 22192cba3ffbSIngo Molnar if (detailed_run < 2) 22202cba3ffbSIngo Molnar return 0; 22212cba3ffbSIngo Molnar 22222cba3ffbSIngo Molnar /* Append very detailed run extra attributes: */ 222379695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0) 22242cba3ffbSIngo Molnar return -1; 22252cba3ffbSIngo Molnar 22262cba3ffbSIngo Molnar if (detailed_run < 3) 22272cba3ffbSIngo Molnar return 0; 22282cba3ffbSIngo Molnar 22292cba3ffbSIngo Molnar /* Append very, very detailed run extra attributes: */ 223079695e1bSArnaldo Carvalho de Melo return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs); 22312cba3ffbSIngo Molnar } 22322cba3ffbSIngo Molnar 22338a59f3ccSJiri Olsa static const char * const stat_record_usage[] = { 22344979d0c7SJiri Olsa "perf stat record [<options>]", 22354979d0c7SJiri Olsa NULL, 22364979d0c7SJiri Olsa }; 22374979d0c7SJiri Olsa 22383ba78bd0SJiri Olsa static void init_features(struct perf_session *session) 22393ba78bd0SJiri Olsa { 22403ba78bd0SJiri Olsa int feat; 22413ba78bd0SJiri Olsa 22423ba78bd0SJiri Olsa for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++) 22433ba78bd0SJiri Olsa perf_header__set_feat(&session->header, feat); 22443ba78bd0SJiri Olsa 22453ba78bd0SJiri Olsa perf_header__clear_feat(&session->header, HEADER_BUILD_ID); 22463ba78bd0SJiri Olsa perf_header__clear_feat(&session->header, HEADER_TRACING_DATA); 22473ba78bd0SJiri Olsa perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK); 22483ba78bd0SJiri Olsa perf_header__clear_feat(&session->header, HEADER_AUXTRACE); 22493ba78bd0SJiri Olsa } 22503ba78bd0SJiri Olsa 22514979d0c7SJiri Olsa static int __cmd_record(int argc, const char **argv) 22524979d0c7SJiri Olsa { 22534979d0c7SJiri Olsa struct perf_session *session; 22544979d0c7SJiri Olsa struct perf_data_file *file = &perf_stat.file; 22554979d0c7SJiri Olsa 22568a59f3ccSJiri Olsa argc = parse_options(argc, argv, stat_options, stat_record_usage, 22574979d0c7SJiri Olsa PARSE_OPT_STOP_AT_NON_OPTION); 22584979d0c7SJiri Olsa 22594979d0c7SJiri Olsa if (output_name) 22604979d0c7SJiri Olsa file->path = output_name; 22614979d0c7SJiri Olsa 2262e9d6db8eSJiri Olsa if (run_count != 1 || forever) { 2263e9d6db8eSJiri Olsa pr_err("Cannot use -r option with perf stat record.\n"); 2264e9d6db8eSJiri Olsa return -1; 2265e9d6db8eSJiri Olsa } 2266e9d6db8eSJiri Olsa 22674979d0c7SJiri Olsa session = perf_session__new(file, false, NULL); 22684979d0c7SJiri Olsa if (session == NULL) { 22694979d0c7SJiri Olsa pr_err("Perf session creation failed.\n"); 22704979d0c7SJiri Olsa return -1; 22714979d0c7SJiri Olsa } 22724979d0c7SJiri Olsa 22733ba78bd0SJiri Olsa init_features(session); 22743ba78bd0SJiri Olsa 22754979d0c7SJiri Olsa session->evlist = evsel_list; 22764979d0c7SJiri Olsa perf_stat.session = session; 22774979d0c7SJiri Olsa perf_stat.record = true; 22784979d0c7SJiri Olsa return argc; 22794979d0c7SJiri Olsa } 22804979d0c7SJiri Olsa 2281a56f9390SJiri Olsa static int process_stat_round_event(struct perf_tool *tool __maybe_unused, 2282a56f9390SJiri Olsa union perf_event *event, 2283a56f9390SJiri Olsa struct perf_session *session) 2284a56f9390SJiri Olsa { 2285e3b03b6cSAndi Kleen struct stat_round_event *stat_round = &event->stat_round; 2286a56f9390SJiri Olsa struct perf_evsel *counter; 2287a56f9390SJiri Olsa struct timespec tsh, *ts = NULL; 2288a56f9390SJiri Olsa const char **argv = session->header.env.cmdline_argv; 2289a56f9390SJiri Olsa int argc = session->header.env.nr_cmdline; 2290a56f9390SJiri Olsa 2291e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) 2292a56f9390SJiri Olsa perf_stat_process_counter(&stat_config, counter); 2293a56f9390SJiri Olsa 2294e3b03b6cSAndi Kleen if (stat_round->type == PERF_STAT_ROUND_TYPE__FINAL) 2295e3b03b6cSAndi Kleen update_stats(&walltime_nsecs_stats, stat_round->time); 2296a56f9390SJiri Olsa 2297e3b03b6cSAndi Kleen if (stat_config.interval && stat_round->time) { 2298bd48c63eSArnaldo Carvalho de Melo tsh.tv_sec = stat_round->time / NSEC_PER_SEC; 2299bd48c63eSArnaldo Carvalho de Melo tsh.tv_nsec = stat_round->time % NSEC_PER_SEC; 2300a56f9390SJiri Olsa ts = &tsh; 2301a56f9390SJiri Olsa } 2302a56f9390SJiri Olsa 2303a56f9390SJiri Olsa print_counters(ts, argc, argv); 2304a56f9390SJiri Olsa return 0; 2305a56f9390SJiri Olsa } 2306a56f9390SJiri Olsa 230762ba18baSJiri Olsa static 23087e6a7998SArnaldo Carvalho de Melo int process_stat_config_event(struct perf_tool *tool, 230962ba18baSJiri Olsa union perf_event *event, 231062ba18baSJiri Olsa struct perf_session *session __maybe_unused) 231162ba18baSJiri Olsa { 231268d702f7SJiri Olsa struct perf_stat *st = container_of(tool, struct perf_stat, tool); 231368d702f7SJiri Olsa 231462ba18baSJiri Olsa perf_event__read_stat_config(&stat_config, &event->stat_config); 231568d702f7SJiri Olsa 231689af4e05SJiri Olsa if (cpu_map__empty(st->cpus)) { 231789af4e05SJiri Olsa if (st->aggr_mode != AGGR_UNSET) 231889af4e05SJiri Olsa pr_warning("warning: processing task data, aggregation mode not set\n"); 231989af4e05SJiri Olsa return 0; 232089af4e05SJiri Olsa } 232189af4e05SJiri Olsa 232289af4e05SJiri Olsa if (st->aggr_mode != AGGR_UNSET) 232389af4e05SJiri Olsa stat_config.aggr_mode = st->aggr_mode; 232489af4e05SJiri Olsa 232568d702f7SJiri Olsa if (perf_stat.file.is_pipe) 232668d702f7SJiri Olsa perf_stat_init_aggr_mode(); 232768d702f7SJiri Olsa else 232868d702f7SJiri Olsa perf_stat_init_aggr_mode_file(st); 232968d702f7SJiri Olsa 233062ba18baSJiri Olsa return 0; 233162ba18baSJiri Olsa } 233262ba18baSJiri Olsa 23331975d36eSJiri Olsa static int set_maps(struct perf_stat *st) 23341975d36eSJiri Olsa { 23351975d36eSJiri Olsa if (!st->cpus || !st->threads) 23361975d36eSJiri Olsa return 0; 23371975d36eSJiri Olsa 23381975d36eSJiri Olsa if (WARN_ONCE(st->maps_allocated, "stats double allocation\n")) 23391975d36eSJiri Olsa return -EINVAL; 23401975d36eSJiri Olsa 23411975d36eSJiri Olsa perf_evlist__set_maps(evsel_list, st->cpus, st->threads); 23421975d36eSJiri Olsa 23431975d36eSJiri Olsa if (perf_evlist__alloc_stats(evsel_list, true)) 23441975d36eSJiri Olsa return -ENOMEM; 23451975d36eSJiri Olsa 23461975d36eSJiri Olsa st->maps_allocated = true; 23471975d36eSJiri Olsa return 0; 23481975d36eSJiri Olsa } 23491975d36eSJiri Olsa 23501975d36eSJiri Olsa static 23517e6a7998SArnaldo Carvalho de Melo int process_thread_map_event(struct perf_tool *tool, 23521975d36eSJiri Olsa union perf_event *event, 23531975d36eSJiri Olsa struct perf_session *session __maybe_unused) 23541975d36eSJiri Olsa { 23551975d36eSJiri Olsa struct perf_stat *st = container_of(tool, struct perf_stat, tool); 23561975d36eSJiri Olsa 23571975d36eSJiri Olsa if (st->threads) { 23581975d36eSJiri Olsa pr_warning("Extra thread map event, ignoring.\n"); 23591975d36eSJiri Olsa return 0; 23601975d36eSJiri Olsa } 23611975d36eSJiri Olsa 23621975d36eSJiri Olsa st->threads = thread_map__new_event(&event->thread_map); 23631975d36eSJiri Olsa if (!st->threads) 23641975d36eSJiri Olsa return -ENOMEM; 23651975d36eSJiri Olsa 23661975d36eSJiri Olsa return set_maps(st); 23671975d36eSJiri Olsa } 23681975d36eSJiri Olsa 23691975d36eSJiri Olsa static 23707e6a7998SArnaldo Carvalho de Melo int process_cpu_map_event(struct perf_tool *tool, 23711975d36eSJiri Olsa union perf_event *event, 23721975d36eSJiri Olsa struct perf_session *session __maybe_unused) 23731975d36eSJiri Olsa { 23741975d36eSJiri Olsa struct perf_stat *st = container_of(tool, struct perf_stat, tool); 23751975d36eSJiri Olsa struct cpu_map *cpus; 23761975d36eSJiri Olsa 23771975d36eSJiri Olsa if (st->cpus) { 23781975d36eSJiri Olsa pr_warning("Extra cpu map event, ignoring.\n"); 23791975d36eSJiri Olsa return 0; 23801975d36eSJiri Olsa } 23811975d36eSJiri Olsa 23821975d36eSJiri Olsa cpus = cpu_map__new_data(&event->cpu_map.data); 23831975d36eSJiri Olsa if (!cpus) 23841975d36eSJiri Olsa return -ENOMEM; 23851975d36eSJiri Olsa 23861975d36eSJiri Olsa st->cpus = cpus; 23871975d36eSJiri Olsa return set_maps(st); 23881975d36eSJiri Olsa } 23891975d36eSJiri Olsa 23908a59f3ccSJiri Olsa static const char * const stat_report_usage[] = { 2391ba6039b6SJiri Olsa "perf stat report [<options>]", 2392ba6039b6SJiri Olsa NULL, 2393ba6039b6SJiri Olsa }; 2394ba6039b6SJiri Olsa 2395ba6039b6SJiri Olsa static struct perf_stat perf_stat = { 2396ba6039b6SJiri Olsa .tool = { 2397ba6039b6SJiri Olsa .attr = perf_event__process_attr, 2398fa6ea781SJiri Olsa .event_update = perf_event__process_event_update, 23991975d36eSJiri Olsa .thread_map = process_thread_map_event, 24001975d36eSJiri Olsa .cpu_map = process_cpu_map_event, 240162ba18baSJiri Olsa .stat_config = process_stat_config_event, 2402a56f9390SJiri Olsa .stat = perf_event__process_stat_event, 2403a56f9390SJiri Olsa .stat_round = process_stat_round_event, 2404ba6039b6SJiri Olsa }, 240589af4e05SJiri Olsa .aggr_mode = AGGR_UNSET, 2406ba6039b6SJiri Olsa }; 2407ba6039b6SJiri Olsa 2408ba6039b6SJiri Olsa static int __cmd_report(int argc, const char **argv) 2409ba6039b6SJiri Olsa { 2410ba6039b6SJiri Olsa struct perf_session *session; 2411ba6039b6SJiri Olsa const struct option options[] = { 2412ba6039b6SJiri Olsa OPT_STRING('i', "input", &input_name, "file", "input file name"), 241389af4e05SJiri Olsa OPT_SET_UINT(0, "per-socket", &perf_stat.aggr_mode, 241489af4e05SJiri Olsa "aggregate counts per processor socket", AGGR_SOCKET), 241589af4e05SJiri Olsa OPT_SET_UINT(0, "per-core", &perf_stat.aggr_mode, 241689af4e05SJiri Olsa "aggregate counts per physical processor core", AGGR_CORE), 241789af4e05SJiri Olsa OPT_SET_UINT('A', "no-aggr", &perf_stat.aggr_mode, 241889af4e05SJiri Olsa "disable CPU count aggregation", AGGR_NONE), 2419ba6039b6SJiri Olsa OPT_END() 2420ba6039b6SJiri Olsa }; 2421ba6039b6SJiri Olsa struct stat st; 2422ba6039b6SJiri Olsa int ret; 2423ba6039b6SJiri Olsa 24248a59f3ccSJiri Olsa argc = parse_options(argc, argv, options, stat_report_usage, 0); 2425ba6039b6SJiri Olsa 2426ba6039b6SJiri Olsa if (!input_name || !strlen(input_name)) { 2427ba6039b6SJiri Olsa if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode)) 2428ba6039b6SJiri Olsa input_name = "-"; 2429ba6039b6SJiri Olsa else 2430ba6039b6SJiri Olsa input_name = "perf.data"; 2431ba6039b6SJiri Olsa } 2432ba6039b6SJiri Olsa 2433ba6039b6SJiri Olsa perf_stat.file.path = input_name; 2434ba6039b6SJiri Olsa perf_stat.file.mode = PERF_DATA_MODE_READ; 2435ba6039b6SJiri Olsa 2436ba6039b6SJiri Olsa session = perf_session__new(&perf_stat.file, false, &perf_stat.tool); 2437ba6039b6SJiri Olsa if (session == NULL) 2438ba6039b6SJiri Olsa return -1; 2439ba6039b6SJiri Olsa 2440ba6039b6SJiri Olsa perf_stat.session = session; 2441ba6039b6SJiri Olsa stat_config.output = stderr; 2442ba6039b6SJiri Olsa evsel_list = session->evlist; 2443ba6039b6SJiri Olsa 2444ba6039b6SJiri Olsa ret = perf_session__process_events(session); 2445ba6039b6SJiri Olsa if (ret) 2446ba6039b6SJiri Olsa return ret; 2447ba6039b6SJiri Olsa 2448ba6039b6SJiri Olsa perf_session__delete(session); 2449ba6039b6SJiri Olsa return 0; 2450ba6039b6SJiri Olsa } 2451ba6039b6SJiri Olsa 2452e3ba76deSJiri Olsa static void setup_system_wide(int forks) 2453e3ba76deSJiri Olsa { 2454e3ba76deSJiri Olsa /* 2455e3ba76deSJiri Olsa * Make system wide (-a) the default target if 2456e3ba76deSJiri Olsa * no target was specified and one of following 2457e3ba76deSJiri Olsa * conditions is met: 2458e3ba76deSJiri Olsa * 2459e3ba76deSJiri Olsa * - there's no workload specified 2460e3ba76deSJiri Olsa * - there is workload specified but all requested 2461e3ba76deSJiri Olsa * events are system wide events 2462e3ba76deSJiri Olsa */ 2463e3ba76deSJiri Olsa if (!target__none(&target)) 2464e3ba76deSJiri Olsa return; 2465e3ba76deSJiri Olsa 2466e3ba76deSJiri Olsa if (!forks) 2467e3ba76deSJiri Olsa target.system_wide = true; 2468e3ba76deSJiri Olsa else { 2469e3ba76deSJiri Olsa struct perf_evsel *counter; 2470e3ba76deSJiri Olsa 2471e3ba76deSJiri Olsa evlist__for_each_entry(evsel_list, counter) { 2472e3ba76deSJiri Olsa if (!counter->system_wide) 2473e3ba76deSJiri Olsa return; 2474e3ba76deSJiri Olsa } 2475e3ba76deSJiri Olsa 2476e3ba76deSJiri Olsa if (evsel_list->nr_entries) 2477e3ba76deSJiri Olsa target.system_wide = true; 2478e3ba76deSJiri Olsa } 2479e3ba76deSJiri Olsa } 2480e3ba76deSJiri Olsa 2481b0ad8ea6SArnaldo Carvalho de Melo int cmd_stat(int argc, const char **argv) 248286470930SIngo Molnar { 2483b070a547SArnaldo Carvalho de Melo const char * const stat_usage[] = { 2484b070a547SArnaldo Carvalho de Melo "perf stat [<options>] [<command>]", 2485b070a547SArnaldo Carvalho de Melo NULL 2486b070a547SArnaldo Carvalho de Melo }; 2487cc03c542SNamhyung Kim int status = -EINVAL, run_idx; 24884aa9015fSStephane Eranian const char *mode; 24895821522eSJiri Olsa FILE *output = stderr; 2490ec0d3d1fSJiri Olsa unsigned int interval; 2491ba6039b6SJiri Olsa const char * const stat_subcommands[] = { "record", "report" }; 249242202dd5SIngo Molnar 24935af52b51SStephane Eranian setlocale(LC_ALL, ""); 24945af52b51SStephane Eranian 2495334fe7a3SNamhyung Kim evsel_list = perf_evlist__new(); 2496361c99a6SArnaldo Carvalho de Melo if (evsel_list == NULL) 2497361c99a6SArnaldo Carvalho de Melo return -ENOMEM; 2498361c99a6SArnaldo Carvalho de Melo 24991669e509SWang Nan parse_events__shrink_config_terms(); 25004979d0c7SJiri Olsa argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands, 25014979d0c7SJiri Olsa (const char **) stat_usage, 2502a0541234SAnton Blanchard PARSE_OPT_STOP_AT_NON_OPTION); 250337932c18SAndi Kleen perf_stat__collect_metric_expr(evsel_list); 2504fb4605baSAndi Kleen perf_stat__init_shadow_stats(); 2505d7470b6aSStephane Eranian 25066edb78a2SJiri Olsa if (csv_sep) { 25076edb78a2SJiri Olsa csv_output = true; 25086edb78a2SJiri Olsa if (!strcmp(csv_sep, "\\t")) 25096edb78a2SJiri Olsa csv_sep = "\t"; 25106edb78a2SJiri Olsa } else 25116edb78a2SJiri Olsa csv_sep = DEFAULT_SEPARATOR; 25126edb78a2SJiri Olsa 25134979d0c7SJiri Olsa if (argc && !strncmp(argv[0], "rec", 3)) { 25144979d0c7SJiri Olsa argc = __cmd_record(argc, argv); 25154979d0c7SJiri Olsa if (argc < 0) 25164979d0c7SJiri Olsa return -1; 2517ba6039b6SJiri Olsa } else if (argc && !strncmp(argv[0], "rep", 3)) 2518ba6039b6SJiri Olsa return __cmd_report(argc, argv); 25194979d0c7SJiri Olsa 2520ec0d3d1fSJiri Olsa interval = stat_config.interval; 2521ec0d3d1fSJiri Olsa 25224979d0c7SJiri Olsa /* 25234979d0c7SJiri Olsa * For record command the -o is already taken care of. 25244979d0c7SJiri Olsa */ 25254979d0c7SJiri Olsa if (!STAT_RECORD && output_name && strcmp(output_name, "-")) 25264aa9015fSStephane Eranian output = NULL; 25274aa9015fSStephane Eranian 252856f3bae7SJim Cromie if (output_name && output_fd) { 252956f3bae7SJim Cromie fprintf(stderr, "cannot use both --output and --log-fd\n"); 2530e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "o", 1); 2531e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "log-fd", 0); 2532cc03c542SNamhyung Kim goto out; 253356f3bae7SJim Cromie } 2534fc3e4d07SStephane Eranian 253554b50916SAndi Kleen if (metric_only && stat_config.aggr_mode == AGGR_THREAD) { 253654b50916SAndi Kleen fprintf(stderr, "--metric-only is not supported with --per-thread\n"); 253754b50916SAndi Kleen goto out; 253854b50916SAndi Kleen } 253954b50916SAndi Kleen 254054b50916SAndi Kleen if (metric_only && run_count > 1) { 254154b50916SAndi Kleen fprintf(stderr, "--metric-only is not supported with -r\n"); 254254b50916SAndi Kleen goto out; 254354b50916SAndi Kleen } 254454b50916SAndi Kleen 2545fc3e4d07SStephane Eranian if (output_fd < 0) { 2546fc3e4d07SStephane Eranian fprintf(stderr, "argument to --log-fd must be a > 0\n"); 2547e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "log-fd", 0); 2548cc03c542SNamhyung Kim goto out; 2549fc3e4d07SStephane Eranian } 2550fc3e4d07SStephane Eranian 25514aa9015fSStephane Eranian if (!output) { 25524aa9015fSStephane Eranian struct timespec tm; 25534aa9015fSStephane Eranian mode = append_file ? "a" : "w"; 25544aa9015fSStephane Eranian 25554aa9015fSStephane Eranian output = fopen(output_name, mode); 25564aa9015fSStephane Eranian if (!output) { 25574aa9015fSStephane Eranian perror("failed to create output file"); 2558fceda7feSDavid Ahern return -1; 25594aa9015fSStephane Eranian } 25604aa9015fSStephane Eranian clock_gettime(CLOCK_REALTIME, &tm); 25614aa9015fSStephane Eranian fprintf(output, "# started on %s\n", ctime(&tm.tv_sec)); 2562fc3e4d07SStephane Eranian } else if (output_fd > 0) { 256356f3bae7SJim Cromie mode = append_file ? "a" : "w"; 256456f3bae7SJim Cromie output = fdopen(output_fd, mode); 256556f3bae7SJim Cromie if (!output) { 256656f3bae7SJim Cromie perror("Failed opening logfd"); 256756f3bae7SJim Cromie return -errno; 256856f3bae7SJim Cromie } 25694aa9015fSStephane Eranian } 25704aa9015fSStephane Eranian 25715821522eSJiri Olsa stat_config.output = output; 25725821522eSJiri Olsa 2573d7470b6aSStephane Eranian /* 2574d7470b6aSStephane Eranian * let the spreadsheet do the pretty-printing 2575d7470b6aSStephane Eranian */ 2576d7470b6aSStephane Eranian if (csv_output) { 257761a9f324SJim Cromie /* User explicitly passed -B? */ 2578d7470b6aSStephane Eranian if (big_num_opt == 1) { 2579d7470b6aSStephane Eranian fprintf(stderr, "-B option not supported with -x\n"); 2580e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "B", 1); 2581e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "x", 1); 2582cc03c542SNamhyung Kim goto out; 2583d7470b6aSStephane Eranian } else /* Nope, so disable big number formatting */ 2584d7470b6aSStephane Eranian big_num = false; 2585d7470b6aSStephane Eranian } else if (big_num_opt == 0) /* User passed --no-big-num */ 2586d7470b6aSStephane Eranian big_num = false; 2587d7470b6aSStephane Eranian 2588e3ba76deSJiri Olsa setup_system_wide(argc); 2589ac3063bdSDavid Ahern 2590a7e191c3SFrederik Deweerdt if (run_count < 0) { 2591cc03c542SNamhyung Kim pr_err("Run count must be a positive number\n"); 2592e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "r", 1); 2593cc03c542SNamhyung Kim goto out; 2594a7e191c3SFrederik Deweerdt } else if (run_count == 0) { 2595a7e191c3SFrederik Deweerdt forever = true; 2596a7e191c3SFrederik Deweerdt run_count = 1; 2597a7e191c3SFrederik Deweerdt } 259886470930SIngo Molnar 2599421a50f3SJiri Olsa if ((stat_config.aggr_mode == AGGR_THREAD) && !target__has_task(&target)) { 260032b8af82SJiri Olsa fprintf(stderr, "The --per-thread option is only available " 260132b8af82SJiri Olsa "when monitoring via -p -t options.\n"); 2602e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "p", 1); 2603e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "t", 1); 260432b8af82SJiri Olsa goto out; 260532b8af82SJiri Olsa } 260632b8af82SJiri Olsa 260732b8af82SJiri Olsa /* 260832b8af82SJiri Olsa * no_aggr, cgroup are for system-wide only 260932b8af82SJiri Olsa * --per-thread is aggregated per thread, we dont mix it with cpu mode 261032b8af82SJiri Olsa */ 2611421a50f3SJiri Olsa if (((stat_config.aggr_mode != AGGR_GLOBAL && 2612421a50f3SJiri Olsa stat_config.aggr_mode != AGGR_THREAD) || nr_cgroups) && 2613602ad878SArnaldo Carvalho de Melo !target__has_cpu(&target)) { 2614023695d9SStephane Eranian fprintf(stderr, "both cgroup and no-aggregation " 2615023695d9SStephane Eranian "modes only available in system-wide mode\n"); 2616023695d9SStephane Eranian 2617e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "G", 1); 2618e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "A", 1); 2619e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "a", 1); 2620cc03c542SNamhyung Kim goto out; 2621d7e7a451SStephane Eranian } 2622d7e7a451SStephane Eranian 26232cba3ffbSIngo Molnar if (add_default_attributes()) 2624c6264defSIngo Molnar goto out; 262586470930SIngo Molnar 2626602ad878SArnaldo Carvalho de Melo target__validate(&target); 26275c98d466SArnaldo Carvalho de Melo 262877a6f014SNamhyung Kim if (perf_evlist__create_maps(evsel_list, &target) < 0) { 2629602ad878SArnaldo Carvalho de Melo if (target__has_task(&target)) { 26305c98d466SArnaldo Carvalho de Melo pr_err("Problems finding threads of monitor\n"); 2631e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "p", 1); 2632e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "t", 1); 2633602ad878SArnaldo Carvalho de Melo } else if (target__has_cpu(&target)) { 263460d567e2SArnaldo Carvalho de Melo perror("failed to parse CPUs map"); 2635e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "C", 1); 2636e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "a", 1); 2637cc03c542SNamhyung Kim } 2638cc03c542SNamhyung Kim goto out; 263960d567e2SArnaldo Carvalho de Melo } 264032b8af82SJiri Olsa 264132b8af82SJiri Olsa /* 264232b8af82SJiri Olsa * Initialize thread_map with comm names, 264332b8af82SJiri Olsa * so we could print it out on output. 264432b8af82SJiri Olsa */ 2645421a50f3SJiri Olsa if (stat_config.aggr_mode == AGGR_THREAD) 264632b8af82SJiri Olsa thread_map__read_comms(evsel_list->threads); 264732b8af82SJiri Olsa 264813370a9bSStephane Eranian if (interval && interval < 100) { 264919afd104SKan Liang if (interval < 10) { 265019afd104SKan Liang pr_err("print interval must be >= 10ms\n"); 2651e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "I", 1); 265203ad9747SArnaldo Carvalho de Melo goto out; 265319afd104SKan Liang } else 265419afd104SKan Liang pr_warning("print interval < 100ms. " 265519afd104SKan Liang "The overhead percentage could be high in some cases. " 265619afd104SKan Liang "Please proceed with caution.\n"); 265713370a9bSStephane Eranian } 2658c45c6ea2SStephane Eranian 2659d134ffb9SArnaldo Carvalho de Melo if (perf_evlist__alloc_stats(evsel_list, interval)) 266003ad9747SArnaldo Carvalho de Melo goto out; 2661d6d901c2SZhang, Yanmin 266286ee6e18SStephane Eranian if (perf_stat_init_aggr_mode()) 266303ad9747SArnaldo Carvalho de Melo goto out; 266486ee6e18SStephane Eranian 266586470930SIngo Molnar /* 266686470930SIngo Molnar * We dont want to block the signals - that would cause 266786470930SIngo Molnar * child tasks to inherit that and Ctrl-C would not work. 266886470930SIngo Molnar * What we want is for Ctrl-C to work in the exec()-ed 266986470930SIngo Molnar * task, but being ignored by perf stat itself: 267086470930SIngo Molnar */ 2671f7b7c26eSPeter Zijlstra atexit(sig_atexit); 2672a7e191c3SFrederik Deweerdt if (!forever) 267386470930SIngo Molnar signal(SIGINT, skip_signal); 267413370a9bSStephane Eranian signal(SIGCHLD, skip_signal); 267586470930SIngo Molnar signal(SIGALRM, skip_signal); 267686470930SIngo Molnar signal(SIGABRT, skip_signal); 267786470930SIngo Molnar 267842202dd5SIngo Molnar status = 0; 2679a7e191c3SFrederik Deweerdt for (run_idx = 0; forever || run_idx < run_count; run_idx++) { 2680bb963e16SNamhyung Kim if (run_count != 1 && verbose > 0) 26814aa9015fSStephane Eranian fprintf(output, "[ perf stat: executing run #%d ... ]\n", 26824aa9015fSStephane Eranian run_idx + 1); 2683f9cef0a9SIngo Molnar 268442202dd5SIngo Molnar status = run_perf_stat(argc, argv); 2685a7e191c3SFrederik Deweerdt if (forever && status != -1) { 2686d4f63a47SJiri Olsa print_counters(NULL, argc, argv); 2687254ecbc7SJiri Olsa perf_stat__reset_stats(); 2688a7e191c3SFrederik Deweerdt } 268942202dd5SIngo Molnar } 269042202dd5SIngo Molnar 2691a7e191c3SFrederik Deweerdt if (!forever && status != -1 && !interval) 2692d4f63a47SJiri Olsa print_counters(NULL, argc, argv); 2693d134ffb9SArnaldo Carvalho de Melo 26944979d0c7SJiri Olsa if (STAT_RECORD) { 26954979d0c7SJiri Olsa /* 26964979d0c7SJiri Olsa * We synthesize the kernel mmap record just so that older tools 26974979d0c7SJiri Olsa * don't emit warnings about not being able to resolve symbols 26984979d0c7SJiri Olsa * due to /proc/sys/kernel/kptr_restrict settings and instear provide 26994979d0c7SJiri Olsa * a saner message about no samples being in the perf.data file. 27004979d0c7SJiri Olsa * 27014979d0c7SJiri Olsa * This also serves to suppress a warning about f_header.data.size == 0 27028b99b1a4SJiri Olsa * in header.c at the moment 'perf stat record' gets introduced, which 27038b99b1a4SJiri Olsa * is not really needed once we start adding the stat specific PERF_RECORD_ 27048b99b1a4SJiri Olsa * records, but the need to suppress the kptr_restrict messages in older 27058b99b1a4SJiri Olsa * tools remain -acme 27064979d0c7SJiri Olsa */ 27074979d0c7SJiri Olsa int fd = perf_data_file__fd(&perf_stat.file); 27084979d0c7SJiri Olsa int err = perf_event__synthesize_kernel_mmap((void *)&perf_stat, 27094979d0c7SJiri Olsa process_synthesized_event, 27104979d0c7SJiri Olsa &perf_stat.session->machines.host); 27114979d0c7SJiri Olsa if (err) { 27124979d0c7SJiri Olsa pr_warning("Couldn't synthesize the kernel mmap record, harmless, " 27134979d0c7SJiri Olsa "older tools may produce warnings about this file\n."); 27144979d0c7SJiri Olsa } 27154979d0c7SJiri Olsa 27167aad0c32SJiri Olsa if (!interval) { 27177aad0c32SJiri Olsa if (WRITE_STAT_ROUND_EVENT(walltime_nsecs_stats.max, FINAL)) 27187aad0c32SJiri Olsa pr_err("failed to write stat round event\n"); 27197aad0c32SJiri Olsa } 27207aad0c32SJiri Olsa 2721664c98d4SJiri Olsa if (!perf_stat.file.is_pipe) { 27224979d0c7SJiri Olsa perf_stat.session->header.data_size += perf_stat.bytes_written; 27234979d0c7SJiri Olsa perf_session__write_header(perf_stat.session, evsel_list, fd, true); 2724664c98d4SJiri Olsa } 27254979d0c7SJiri Olsa 27264979d0c7SJiri Olsa perf_session__delete(perf_stat.session); 27274979d0c7SJiri Olsa } 27284979d0c7SJiri Olsa 2729544c2ae7SMasami Hiramatsu perf_stat__exit_aggr_mode(); 2730d134ffb9SArnaldo Carvalho de Melo perf_evlist__free_stats(evsel_list); 27310015e2e1SArnaldo Carvalho de Melo out: 27320015e2e1SArnaldo Carvalho de Melo perf_evlist__delete(evsel_list); 273342202dd5SIngo Molnar return status; 273486470930SIngo Molnar } 2735