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); 3153b3eb044SJiri Olsa if (perf_evsel__read(counter, cpu, thread, count)) 316c52b12edSArnaldo Carvalho de Melo return -1; 3175a6ea81bSJiri Olsa 3185a6ea81bSJiri Olsa if (STAT_RECORD) { 3195a6ea81bSJiri Olsa if (perf_evsel__write_stat_event(counter, cpu, thread, count)) { 3205a6ea81bSJiri Olsa pr_err("failed to write stat event\n"); 3215a6ea81bSJiri Olsa return -1; 3225a6ea81bSJiri Olsa } 3235a6ea81bSJiri Olsa } 3240b1abbf4SAndi Kleen 3250b1abbf4SAndi Kleen if (verbose > 1) { 3260b1abbf4SAndi Kleen fprintf(stat_config.output, 3270b1abbf4SAndi Kleen "%s: %d: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n", 3280b1abbf4SAndi Kleen perf_evsel__name(counter), 3290b1abbf4SAndi Kleen cpu, 3300b1abbf4SAndi Kleen count->val, count->ena, count->run); 3310b1abbf4SAndi Kleen } 332f5b4a9c3SStephane Eranian } 3339bf1a529SJiri Olsa } 334c52b12edSArnaldo Carvalho de Melo 335c52b12edSArnaldo Carvalho de Melo return 0; 33686470930SIngo Molnar } 33786470930SIngo Molnar 3383df33effSMark Rutland static void read_counters(void) 339106a94a0SJiri Olsa { 340106a94a0SJiri Olsa struct perf_evsel *counter; 341106a94a0SJiri Olsa 342e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 3433b3eb044SJiri Olsa if (read_counter(counter)) 344245bad8eSAndi Kleen pr_debug("failed to read counter %s\n", counter->name); 3453b3eb044SJiri Olsa 346f80010ebSJiri Olsa if (perf_stat_process_counter(&stat_config, counter)) 3473b3eb044SJiri Olsa pr_warning("failed to process counter %s\n", counter->name); 348106a94a0SJiri Olsa } 349106a94a0SJiri Olsa } 350106a94a0SJiri Olsa 351ba411a95SJiri Olsa static void process_interval(void) 35213370a9bSStephane Eranian { 35313370a9bSStephane Eranian struct timespec ts, rs; 35413370a9bSStephane Eranian 3553df33effSMark Rutland read_counters(); 35686ee6e18SStephane Eranian 35713370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ts); 35813370a9bSStephane Eranian diff_timespec(&rs, &ts, &ref_time); 35913370a9bSStephane Eranian 3607aad0c32SJiri Olsa if (STAT_RECORD) { 361bd48c63eSArnaldo Carvalho de Melo if (WRITE_STAT_ROUND_EVENT(rs.tv_sec * NSEC_PER_SEC + rs.tv_nsec, INTERVAL)) 3627aad0c32SJiri Olsa pr_err("failed to write stat round event\n"); 3637aad0c32SJiri Olsa } 3647aad0c32SJiri Olsa 365d4f63a47SJiri Olsa print_counters(&rs, 0, NULL); 36613370a9bSStephane Eranian } 36713370a9bSStephane Eranian 36867ccdecdSJiri Olsa static void enable_counters(void) 36941191688SAndi Kleen { 37067ccdecdSJiri Olsa if (initial_delay) 371310ebb93SArnaldo Carvalho de Melo usleep(initial_delay * USEC_PER_MSEC); 37267ccdecdSJiri Olsa 37367ccdecdSJiri Olsa /* 37467ccdecdSJiri Olsa * We need to enable counters only if: 37567ccdecdSJiri Olsa * - we don't have tracee (attaching to task or cpu) 37667ccdecdSJiri Olsa * - we have initial delay configured 37767ccdecdSJiri Olsa */ 37867ccdecdSJiri Olsa if (!target__none(&target) || initial_delay) 379ab46db0aSJiri Olsa perf_evlist__enable(evsel_list); 38041191688SAndi Kleen } 38141191688SAndi Kleen 3823df33effSMark Rutland static void disable_counters(void) 3833df33effSMark Rutland { 3843df33effSMark Rutland /* 3853df33effSMark Rutland * If we don't have tracee (attaching to task or cpu), counters may 3863df33effSMark Rutland * still be running. To get accurate group ratios, we must stop groups 3873df33effSMark Rutland * from counting before reading their constituent counters. 3883df33effSMark Rutland */ 3893df33effSMark Rutland if (!target__none(&target)) 3903df33effSMark Rutland perf_evlist__disable(evsel_list); 3913df33effSMark Rutland } 3923df33effSMark Rutland 393f33cbe72SArnaldo Carvalho de Melo static volatile int workload_exec_errno; 3946af206fdSArnaldo Carvalho de Melo 3956af206fdSArnaldo Carvalho de Melo /* 3966af206fdSArnaldo Carvalho de Melo * perf_evlist__prepare_workload will send a SIGUSR1 3976af206fdSArnaldo Carvalho de Melo * if the fork fails, since we asked by setting its 3986af206fdSArnaldo Carvalho de Melo * want_signal to true. 3996af206fdSArnaldo Carvalho de Melo */ 400f33cbe72SArnaldo Carvalho de Melo static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info, 401f33cbe72SArnaldo Carvalho de Melo void *ucontext __maybe_unused) 4026af206fdSArnaldo Carvalho de Melo { 403f33cbe72SArnaldo Carvalho de Melo workload_exec_errno = info->si_value.sival_int; 4046af206fdSArnaldo Carvalho de Melo } 4056af206fdSArnaldo Carvalho de Melo 4067b60a7e3SJiri Olsa static bool has_unit(struct perf_evsel *counter) 4077b60a7e3SJiri Olsa { 4087b60a7e3SJiri Olsa return counter->unit && *counter->unit; 4097b60a7e3SJiri Olsa } 4107b60a7e3SJiri Olsa 4117b60a7e3SJiri Olsa static bool has_scale(struct perf_evsel *counter) 4127b60a7e3SJiri Olsa { 4137b60a7e3SJiri Olsa return counter->scale != 1; 4147b60a7e3SJiri Olsa } 4157b60a7e3SJiri Olsa 416664c98d4SJiri Olsa static int perf_stat_synthesize_config(bool is_pipe) 4178b99b1a4SJiri Olsa { 4187b60a7e3SJiri Olsa struct perf_evsel *counter; 4198b99b1a4SJiri Olsa int err; 4208b99b1a4SJiri Olsa 421664c98d4SJiri Olsa if (is_pipe) { 422664c98d4SJiri Olsa err = perf_event__synthesize_attrs(NULL, perf_stat.session, 423664c98d4SJiri Olsa process_synthesized_event); 424664c98d4SJiri Olsa if (err < 0) { 425664c98d4SJiri Olsa pr_err("Couldn't synthesize attrs.\n"); 426664c98d4SJiri Olsa return err; 427664c98d4SJiri Olsa } 428664c98d4SJiri Olsa } 429664c98d4SJiri Olsa 4307b60a7e3SJiri Olsa /* 4317b60a7e3SJiri Olsa * Synthesize other events stuff not carried within 4327b60a7e3SJiri Olsa * attr event - unit, scale, name 4337b60a7e3SJiri Olsa */ 434e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 4357b60a7e3SJiri Olsa if (!counter->supported) 4367b60a7e3SJiri Olsa continue; 4377b60a7e3SJiri Olsa 4387b60a7e3SJiri Olsa /* 4397b60a7e3SJiri Olsa * Synthesize unit and scale only if it's defined. 4407b60a7e3SJiri Olsa */ 4417b60a7e3SJiri Olsa if (has_unit(counter)) { 4427b60a7e3SJiri Olsa err = perf_event__synthesize_event_update_unit(NULL, counter, process_synthesized_event); 4437b60a7e3SJiri Olsa if (err < 0) { 4447b60a7e3SJiri Olsa pr_err("Couldn't synthesize evsel unit.\n"); 4457b60a7e3SJiri Olsa return err; 4467b60a7e3SJiri Olsa } 4477b60a7e3SJiri Olsa } 4487b60a7e3SJiri Olsa 4497b60a7e3SJiri Olsa if (has_scale(counter)) { 4507b60a7e3SJiri Olsa err = perf_event__synthesize_event_update_scale(NULL, counter, process_synthesized_event); 4517b60a7e3SJiri Olsa if (err < 0) { 4527b60a7e3SJiri Olsa pr_err("Couldn't synthesize evsel scale.\n"); 4537b60a7e3SJiri Olsa return err; 4547b60a7e3SJiri Olsa } 4557b60a7e3SJiri Olsa } 4567b60a7e3SJiri Olsa 4577b60a7e3SJiri Olsa if (counter->own_cpus) { 4587b60a7e3SJiri Olsa err = perf_event__synthesize_event_update_cpus(NULL, counter, process_synthesized_event); 4597b60a7e3SJiri Olsa if (err < 0) { 4607b60a7e3SJiri Olsa pr_err("Couldn't synthesize evsel scale.\n"); 4617b60a7e3SJiri Olsa return err; 4627b60a7e3SJiri Olsa } 4637b60a7e3SJiri Olsa } 4647b60a7e3SJiri Olsa 4657b60a7e3SJiri Olsa /* 4667b60a7e3SJiri Olsa * Name is needed only for pipe output, 4677b60a7e3SJiri Olsa * perf.data carries event names. 4687b60a7e3SJiri Olsa */ 4697b60a7e3SJiri Olsa if (is_pipe) { 4707b60a7e3SJiri Olsa err = perf_event__synthesize_event_update_name(NULL, counter, process_synthesized_event); 4717b60a7e3SJiri Olsa if (err < 0) { 4727b60a7e3SJiri Olsa pr_err("Couldn't synthesize evsel name.\n"); 4737b60a7e3SJiri Olsa return err; 4747b60a7e3SJiri Olsa } 4757b60a7e3SJiri Olsa } 4767b60a7e3SJiri Olsa } 4777b60a7e3SJiri Olsa 4788b99b1a4SJiri Olsa err = perf_event__synthesize_thread_map2(NULL, evsel_list->threads, 4798b99b1a4SJiri Olsa process_synthesized_event, 4808b99b1a4SJiri Olsa NULL); 4818b99b1a4SJiri Olsa if (err < 0) { 4828b99b1a4SJiri Olsa pr_err("Couldn't synthesize thread map.\n"); 4838b99b1a4SJiri Olsa return err; 4848b99b1a4SJiri Olsa } 4858b99b1a4SJiri Olsa 4868b99b1a4SJiri Olsa err = perf_event__synthesize_cpu_map(NULL, evsel_list->cpus, 4878b99b1a4SJiri Olsa process_synthesized_event, NULL); 4888b99b1a4SJiri Olsa if (err < 0) { 4898b99b1a4SJiri Olsa pr_err("Couldn't synthesize thread map.\n"); 4908b99b1a4SJiri Olsa return err; 4918b99b1a4SJiri Olsa } 4928b99b1a4SJiri Olsa 4938b99b1a4SJiri Olsa err = perf_event__synthesize_stat_config(NULL, &stat_config, 4948b99b1a4SJiri Olsa process_synthesized_event, NULL); 4958b99b1a4SJiri Olsa if (err < 0) { 4968b99b1a4SJiri Olsa pr_err("Couldn't synthesize config.\n"); 4978b99b1a4SJiri Olsa return err; 4988b99b1a4SJiri Olsa } 4998b99b1a4SJiri Olsa 5008b99b1a4SJiri Olsa return 0; 5018b99b1a4SJiri Olsa } 5028b99b1a4SJiri Olsa 5032af4646dSJiri Olsa #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y)) 5042af4646dSJiri Olsa 5052af4646dSJiri Olsa static int __store_counter_ids(struct perf_evsel *counter, 5062af4646dSJiri Olsa struct cpu_map *cpus, 5072af4646dSJiri Olsa struct thread_map *threads) 5082af4646dSJiri Olsa { 5092af4646dSJiri Olsa int cpu, thread; 5102af4646dSJiri Olsa 5112af4646dSJiri Olsa for (cpu = 0; cpu < cpus->nr; cpu++) { 5122af4646dSJiri Olsa for (thread = 0; thread < threads->nr; thread++) { 5132af4646dSJiri Olsa int fd = FD(counter, cpu, thread); 5142af4646dSJiri Olsa 5152af4646dSJiri Olsa if (perf_evlist__id_add_fd(evsel_list, counter, 5162af4646dSJiri Olsa cpu, thread, fd) < 0) 5172af4646dSJiri Olsa return -1; 5182af4646dSJiri Olsa } 5192af4646dSJiri Olsa } 5202af4646dSJiri Olsa 5212af4646dSJiri Olsa return 0; 5222af4646dSJiri Olsa } 5232af4646dSJiri Olsa 5242af4646dSJiri Olsa static int store_counter_ids(struct perf_evsel *counter) 5252af4646dSJiri Olsa { 5262af4646dSJiri Olsa struct cpu_map *cpus = counter->cpus; 5272af4646dSJiri Olsa struct thread_map *threads = counter->threads; 5282af4646dSJiri Olsa 5292af4646dSJiri Olsa if (perf_evsel__alloc_id(counter, cpus->nr, threads->nr)) 5302af4646dSJiri Olsa return -ENOMEM; 5312af4646dSJiri Olsa 5322af4646dSJiri Olsa return __store_counter_ids(counter, cpus, threads); 5332af4646dSJiri Olsa } 5342af4646dSJiri Olsa 535acf28922SNamhyung Kim static int __run_perf_stat(int argc, const char **argv) 53686470930SIngo Molnar { 537ec0d3d1fSJiri Olsa int interval = stat_config.interval; 538d6195a6aSArnaldo Carvalho de Melo char msg[BUFSIZ]; 53986470930SIngo Molnar unsigned long long t0, t1; 540cac21425SJiri Olsa struct perf_evsel *counter; 54113370a9bSStephane Eranian struct timespec ts; 542410136f5SStephane Eranian size_t l; 54342202dd5SIngo Molnar int status = 0; 5446be2850eSZhang, Yanmin const bool forks = (argc > 0); 545664c98d4SJiri Olsa bool is_pipe = STAT_RECORD ? perf_stat.file.is_pipe : false; 5465d8bb1ecSMathieu Poirier struct perf_evsel_config_term *err_term; 54786470930SIngo Molnar 54813370a9bSStephane Eranian if (interval) { 549310ebb93SArnaldo Carvalho de Melo ts.tv_sec = interval / USEC_PER_MSEC; 550310ebb93SArnaldo Carvalho de Melo ts.tv_nsec = (interval % USEC_PER_MSEC) * NSEC_PER_MSEC; 55113370a9bSStephane Eranian } else { 55213370a9bSStephane Eranian ts.tv_sec = 1; 55313370a9bSStephane Eranian ts.tv_nsec = 0; 55413370a9bSStephane Eranian } 55513370a9bSStephane Eranian 556acf28922SNamhyung Kim if (forks) { 557664c98d4SJiri Olsa if (perf_evlist__prepare_workload(evsel_list, &target, argv, is_pipe, 558735f7e0bSArnaldo Carvalho de Melo workload_exec_failed_signal) < 0) { 559acf28922SNamhyung Kim perror("failed to prepare workload"); 560fceda7feSDavid Ahern return -1; 561051ae7f7SPaul Mackerras } 562d20a47e7SNamhyung Kim child_pid = evsel_list->workload.pid; 56360666c63SLiming Wang } 564051ae7f7SPaul Mackerras 5656a4bb04cSJiri Olsa if (group) 56663dab225SArnaldo Carvalho de Melo perf_evlist__set_leader(evsel_list); 5676a4bb04cSJiri Olsa 568e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 56942ef8a78SArnaldo Carvalho de Melo try_again: 570cac21425SJiri Olsa if (create_perf_stat_counter(counter) < 0) { 571979987a5SDavid Ahern /* 572979987a5SDavid Ahern * PPC returns ENXIO for HW counters until 2.6.37 573979987a5SDavid Ahern * (behavior changed with commit b0a873e). 574979987a5SDavid Ahern */ 57538f6ae1eSAnton Blanchard if (errno == EINVAL || errno == ENOSYS || 576979987a5SDavid Ahern errno == ENOENT || errno == EOPNOTSUPP || 577979987a5SDavid Ahern errno == ENXIO) { 578bb963e16SNamhyung Kim if (verbose > 0) 579c63ca0c0SDavid Ahern ui__warning("%s event is not supported by the kernel.\n", 5807289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 5812cee77c4SDavid Ahern counter->supported = false; 582cb5ef600SKan Liang 583cb5ef600SKan Liang if ((counter->leader != counter) || 584cb5ef600SKan Liang !(counter->leader->nr_members > 1)) 585ede70290SIngo Molnar continue; 58642ef8a78SArnaldo Carvalho de Melo } else if (perf_evsel__fallback(counter, errno, msg, sizeof(msg))) { 587bb963e16SNamhyung Kim if (verbose > 0) 58842ef8a78SArnaldo Carvalho de Melo ui__warning("%s\n", msg); 58942ef8a78SArnaldo Carvalho de Melo goto try_again; 590c63ca0c0SDavid Ahern } 591ede70290SIngo Molnar 59256e52e85SArnaldo Carvalho de Melo perf_evsel__open_strerror(counter, &target, 59356e52e85SArnaldo Carvalho de Melo errno, msg, sizeof(msg)); 59456e52e85SArnaldo Carvalho de Melo ui__error("%s\n", msg); 59556e52e85SArnaldo Carvalho de Melo 596084ab9f8SArnaldo Carvalho de Melo if (child_pid != -1) 597084ab9f8SArnaldo Carvalho de Melo kill(child_pid, SIGTERM); 598fceda7feSDavid Ahern 599084ab9f8SArnaldo Carvalho de Melo return -1; 600084ab9f8SArnaldo Carvalho de Melo } 6012cee77c4SDavid Ahern counter->supported = true; 602410136f5SStephane Eranian 603410136f5SStephane Eranian l = strlen(counter->unit); 604410136f5SStephane Eranian if (l > unit_width) 605410136f5SStephane Eranian unit_width = l; 6062af4646dSJiri Olsa 6072af4646dSJiri Olsa if (STAT_RECORD && store_counter_ids(counter)) 6082af4646dSJiri Olsa return -1; 60948290609SArnaldo Carvalho de Melo } 61086470930SIngo Molnar 61123d4aad4SArnaldo Carvalho de Melo if (perf_evlist__apply_filters(evsel_list, &counter)) { 61223d4aad4SArnaldo Carvalho de Melo error("failed to set filter \"%s\" on event %s with %d (%s)\n", 61323d4aad4SArnaldo Carvalho de Melo counter->filter, perf_evsel__name(counter), errno, 614c8b5f2c9SArnaldo Carvalho de Melo str_error_r(errno, msg, sizeof(msg))); 615cfd748aeSFrederic Weisbecker return -1; 616cfd748aeSFrederic Weisbecker } 617cfd748aeSFrederic Weisbecker 6185d8bb1ecSMathieu Poirier if (perf_evlist__apply_drv_configs(evsel_list, &counter, &err_term)) { 6195d8bb1ecSMathieu Poirier error("failed to set config \"%s\" on event %s with %d (%s)\n", 6205d8bb1ecSMathieu Poirier err_term->val.drv_cfg, perf_evsel__name(counter), errno, 6215d8bb1ecSMathieu Poirier str_error_r(errno, msg, sizeof(msg))); 6225d8bb1ecSMathieu Poirier return -1; 6235d8bb1ecSMathieu Poirier } 6245d8bb1ecSMathieu Poirier 6254979d0c7SJiri Olsa if (STAT_RECORD) { 6264979d0c7SJiri Olsa int err, fd = perf_data_file__fd(&perf_stat.file); 6274979d0c7SJiri Olsa 628664c98d4SJiri Olsa if (is_pipe) { 629664c98d4SJiri Olsa err = perf_header__write_pipe(perf_data_file__fd(&perf_stat.file)); 630664c98d4SJiri Olsa } else { 6314979d0c7SJiri Olsa err = perf_session__write_header(perf_stat.session, evsel_list, 6324979d0c7SJiri Olsa fd, false); 633664c98d4SJiri Olsa } 634664c98d4SJiri Olsa 6354979d0c7SJiri Olsa if (err < 0) 6364979d0c7SJiri Olsa return err; 6378b99b1a4SJiri Olsa 638664c98d4SJiri Olsa err = perf_stat_synthesize_config(is_pipe); 6398b99b1a4SJiri Olsa if (err < 0) 6408b99b1a4SJiri Olsa return err; 6414979d0c7SJiri Olsa } 6424979d0c7SJiri Olsa 64386470930SIngo Molnar /* 64486470930SIngo Molnar * Enable counters and exec the command: 64586470930SIngo Molnar */ 64686470930SIngo Molnar t0 = rdclock(); 64713370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ref_time); 64886470930SIngo Molnar 64960666c63SLiming Wang if (forks) { 650acf28922SNamhyung Kim perf_evlist__start_workload(evsel_list); 65167ccdecdSJiri Olsa enable_counters(); 652acf28922SNamhyung Kim 65313370a9bSStephane Eranian if (interval) { 65413370a9bSStephane Eranian while (!waitpid(child_pid, &status, WNOHANG)) { 65513370a9bSStephane Eranian nanosleep(&ts, NULL); 656ba411a95SJiri Olsa process_interval(); 65713370a9bSStephane Eranian } 65813370a9bSStephane Eranian } 65942202dd5SIngo Molnar wait(&status); 6606af206fdSArnaldo Carvalho de Melo 661f33cbe72SArnaldo Carvalho de Melo if (workload_exec_errno) { 662c8b5f2c9SArnaldo Carvalho de Melo const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg)); 663f33cbe72SArnaldo Carvalho de Melo pr_err("Workload failed: %s\n", emsg); 6646af206fdSArnaldo Carvalho de Melo return -1; 665f33cbe72SArnaldo Carvalho de Melo } 6666af206fdSArnaldo Carvalho de Melo 66733e49ea7SAndi Kleen if (WIFSIGNALED(status)) 66833e49ea7SAndi Kleen psignal(WTERMSIG(status), argv[0]); 66960666c63SLiming Wang } else { 67067ccdecdSJiri Olsa enable_counters(); 67113370a9bSStephane Eranian while (!done) { 67213370a9bSStephane Eranian nanosleep(&ts, NULL); 67313370a9bSStephane Eranian if (interval) 674ba411a95SJiri Olsa process_interval(); 67513370a9bSStephane Eranian } 67660666c63SLiming Wang } 67786470930SIngo Molnar 6783df33effSMark Rutland disable_counters(); 6793df33effSMark Rutland 68086470930SIngo Molnar t1 = rdclock(); 68186470930SIngo Molnar 6829e9772c4SPeter Zijlstra update_stats(&walltime_nsecs_stats, t1 - t0); 68342202dd5SIngo Molnar 6843df33effSMark Rutland /* 6853df33effSMark Rutland * Closing a group leader splits the group, and as we only disable 6863df33effSMark Rutland * group leaders, results in remaining events becoming enabled. To 6873df33effSMark Rutland * avoid arbitrary skew, we must read all counters before closing any 6883df33effSMark Rutland * group leaders. 6893df33effSMark Rutland */ 6903df33effSMark Rutland read_counters(); 6913df33effSMark Rutland perf_evlist__close(evsel_list); 692c52b12edSArnaldo Carvalho de Melo 69342202dd5SIngo Molnar return WEXITSTATUS(status); 69442202dd5SIngo Molnar } 69542202dd5SIngo Molnar 69641cde476SArnaldo Carvalho de Melo static int run_perf_stat(int argc, const char **argv) 6971f16c575SPeter Zijlstra { 6981f16c575SPeter Zijlstra int ret; 6991f16c575SPeter Zijlstra 7001f16c575SPeter Zijlstra if (pre_cmd) { 7011f16c575SPeter Zijlstra ret = system(pre_cmd); 7021f16c575SPeter Zijlstra if (ret) 7031f16c575SPeter Zijlstra return ret; 7041f16c575SPeter Zijlstra } 7051f16c575SPeter Zijlstra 7061f16c575SPeter Zijlstra if (sync_run) 7071f16c575SPeter Zijlstra sync(); 7081f16c575SPeter Zijlstra 7091f16c575SPeter Zijlstra ret = __run_perf_stat(argc, argv); 7101f16c575SPeter Zijlstra if (ret) 7111f16c575SPeter Zijlstra return ret; 7121f16c575SPeter Zijlstra 7131f16c575SPeter Zijlstra if (post_cmd) { 7141f16c575SPeter Zijlstra ret = system(post_cmd); 7151f16c575SPeter Zijlstra if (ret) 7161f16c575SPeter Zijlstra return ret; 7171f16c575SPeter Zijlstra } 7181f16c575SPeter Zijlstra 7191f16c575SPeter Zijlstra return ret; 7201f16c575SPeter Zijlstra } 7211f16c575SPeter Zijlstra 722d73515c0SAndi Kleen static void print_running(u64 run, u64 ena) 723d73515c0SAndi Kleen { 724d73515c0SAndi Kleen if (csv_output) { 7255821522eSJiri Olsa fprintf(stat_config.output, "%s%" PRIu64 "%s%.2f", 726d73515c0SAndi Kleen csv_sep, 727d73515c0SAndi Kleen run, 728d73515c0SAndi Kleen csv_sep, 729d73515c0SAndi Kleen ena ? 100.0 * run / ena : 100.0); 730d73515c0SAndi Kleen } else if (run != ena) { 7315821522eSJiri Olsa fprintf(stat_config.output, " (%.2f%%)", 100.0 * run / ena); 732d73515c0SAndi Kleen } 733d73515c0SAndi Kleen } 734d73515c0SAndi Kleen 735f99844cbSIngo Molnar static void print_noise_pct(double total, double avg) 736f99844cbSIngo Molnar { 7370007eceaSXiao Guangrong double pct = rel_stddev_stats(total, avg); 738f99844cbSIngo Molnar 7393ae9a34dSZhengyu He if (csv_output) 7405821522eSJiri Olsa fprintf(stat_config.output, "%s%.2f%%", csv_sep, pct); 741a1bca6ccSJim Cromie else if (pct) 7425821522eSJiri Olsa fprintf(stat_config.output, " ( +-%6.2f%% )", pct); 743f99844cbSIngo Molnar } 744f99844cbSIngo Molnar 74569aad6f1SArnaldo Carvalho de Melo static void print_noise(struct perf_evsel *evsel, double avg) 74642202dd5SIngo Molnar { 747581cc8a2SJiri Olsa struct perf_stat_evsel *ps; 74869aad6f1SArnaldo Carvalho de Melo 749849abde9SPeter Zijlstra if (run_count == 1) 750849abde9SPeter Zijlstra return; 751849abde9SPeter Zijlstra 75269aad6f1SArnaldo Carvalho de Melo ps = evsel->priv; 753f99844cbSIngo Molnar print_noise_pct(stddev_stats(&ps->res_stats[0]), avg); 75442202dd5SIngo Molnar } 75542202dd5SIngo Molnar 75612c08a9fSStephane Eranian static void aggr_printout(struct perf_evsel *evsel, int id, int nr) 75742202dd5SIngo Molnar { 758421a50f3SJiri Olsa switch (stat_config.aggr_mode) { 75912c08a9fSStephane Eranian case AGGR_CORE: 7605821522eSJiri Olsa fprintf(stat_config.output, "S%d-C%*d%s%*d%s", 76112c08a9fSStephane Eranian cpu_map__id_to_socket(id), 76212c08a9fSStephane Eranian csv_output ? 0 : -8, 76312c08a9fSStephane Eranian cpu_map__id_to_cpu(id), 76412c08a9fSStephane Eranian csv_sep, 76512c08a9fSStephane Eranian csv_output ? 0 : 4, 76612c08a9fSStephane Eranian nr, 76712c08a9fSStephane Eranian csv_sep); 76812c08a9fSStephane Eranian break; 76986ee6e18SStephane Eranian case AGGR_SOCKET: 7705821522eSJiri Olsa fprintf(stat_config.output, "S%*d%s%*d%s", 771d7e7a451SStephane Eranian csv_output ? 0 : -5, 77212c08a9fSStephane Eranian id, 773d7e7a451SStephane Eranian csv_sep, 774d7e7a451SStephane Eranian csv_output ? 0 : 4, 775d7e7a451SStephane Eranian nr, 776d7e7a451SStephane Eranian csv_sep); 77786ee6e18SStephane Eranian break; 77886ee6e18SStephane Eranian case AGGR_NONE: 7795821522eSJiri Olsa fprintf(stat_config.output, "CPU%*d%s", 780d7470b6aSStephane Eranian csv_output ? 0 : -4, 78112c08a9fSStephane Eranian perf_evsel__cpus(evsel)->map[id], csv_sep); 78286ee6e18SStephane Eranian break; 78332b8af82SJiri Olsa case AGGR_THREAD: 7845821522eSJiri Olsa fprintf(stat_config.output, "%*s-%*d%s", 78532b8af82SJiri Olsa csv_output ? 0 : 16, 78632b8af82SJiri Olsa thread_map__comm(evsel->threads, id), 78732b8af82SJiri Olsa csv_output ? 0 : -8, 78832b8af82SJiri Olsa thread_map__pid(evsel->threads, id), 78932b8af82SJiri Olsa csv_sep); 79032b8af82SJiri Olsa break; 79186ee6e18SStephane Eranian case AGGR_GLOBAL: 792208df99eSJiri Olsa case AGGR_UNSET: 79386ee6e18SStephane Eranian default: 79486ee6e18SStephane Eranian break; 79586ee6e18SStephane Eranian } 79686ee6e18SStephane Eranian } 797d7470b6aSStephane Eranian 798140aeadcSAndi Kleen struct outstate { 799140aeadcSAndi Kleen FILE *fh; 800140aeadcSAndi Kleen bool newline; 801f9483392SAndi Kleen const char *prefix; 80292a61f64SAndi Kleen int nfields; 80344d49a60SAndi Kleen int id, nr; 80444d49a60SAndi Kleen struct perf_evsel *evsel; 805140aeadcSAndi Kleen }; 806140aeadcSAndi Kleen 807140aeadcSAndi Kleen #define METRIC_LEN 35 808140aeadcSAndi Kleen 809140aeadcSAndi Kleen static void new_line_std(void *ctx) 810140aeadcSAndi Kleen { 811140aeadcSAndi Kleen struct outstate *os = ctx; 812140aeadcSAndi Kleen 813140aeadcSAndi Kleen os->newline = true; 814140aeadcSAndi Kleen } 815140aeadcSAndi Kleen 816140aeadcSAndi Kleen static void do_new_line_std(struct outstate *os) 817140aeadcSAndi Kleen { 818140aeadcSAndi Kleen fputc('\n', os->fh); 819f9483392SAndi Kleen fputs(os->prefix, os->fh); 82044d49a60SAndi Kleen aggr_printout(os->evsel, os->id, os->nr); 821140aeadcSAndi Kleen if (stat_config.aggr_mode == AGGR_NONE) 822140aeadcSAndi Kleen fprintf(os->fh, " "); 823140aeadcSAndi Kleen fprintf(os->fh, " "); 824140aeadcSAndi Kleen } 825140aeadcSAndi Kleen 826140aeadcSAndi Kleen static void print_metric_std(void *ctx, const char *color, const char *fmt, 827140aeadcSAndi Kleen const char *unit, double val) 828140aeadcSAndi Kleen { 829140aeadcSAndi Kleen struct outstate *os = ctx; 830140aeadcSAndi Kleen FILE *out = os->fh; 831140aeadcSAndi Kleen int n; 832140aeadcSAndi Kleen bool newline = os->newline; 833140aeadcSAndi Kleen 834140aeadcSAndi Kleen os->newline = false; 835140aeadcSAndi Kleen 836140aeadcSAndi Kleen if (unit == NULL || fmt == NULL) { 837140aeadcSAndi Kleen fprintf(out, "%-*s", METRIC_LEN, ""); 838140aeadcSAndi Kleen return; 839140aeadcSAndi Kleen } 840140aeadcSAndi Kleen 841140aeadcSAndi Kleen if (newline) 842140aeadcSAndi Kleen do_new_line_std(os); 843140aeadcSAndi Kleen 844140aeadcSAndi Kleen n = fprintf(out, " # "); 845140aeadcSAndi Kleen if (color) 846140aeadcSAndi Kleen n += color_fprintf(out, color, fmt, val); 847140aeadcSAndi Kleen else 848140aeadcSAndi Kleen n += fprintf(out, fmt, val); 849140aeadcSAndi Kleen fprintf(out, " %-*s", METRIC_LEN - n - 1, unit); 850140aeadcSAndi Kleen } 851140aeadcSAndi Kleen 85292a61f64SAndi Kleen static void new_line_csv(void *ctx) 85392a61f64SAndi Kleen { 85492a61f64SAndi Kleen struct outstate *os = ctx; 85592a61f64SAndi Kleen int i; 85692a61f64SAndi Kleen 85792a61f64SAndi Kleen fputc('\n', os->fh); 85892a61f64SAndi Kleen if (os->prefix) 85992a61f64SAndi Kleen fprintf(os->fh, "%s%s", os->prefix, csv_sep); 86044d49a60SAndi Kleen aggr_printout(os->evsel, os->id, os->nr); 86192a61f64SAndi Kleen for (i = 0; i < os->nfields; i++) 86292a61f64SAndi Kleen fputs(csv_sep, os->fh); 86392a61f64SAndi Kleen } 86492a61f64SAndi Kleen 86592a61f64SAndi Kleen static void print_metric_csv(void *ctx, 86692a61f64SAndi Kleen const char *color __maybe_unused, 86792a61f64SAndi Kleen const char *fmt, const char *unit, double val) 86892a61f64SAndi Kleen { 86992a61f64SAndi Kleen struct outstate *os = ctx; 87092a61f64SAndi Kleen FILE *out = os->fh; 87192a61f64SAndi Kleen char buf[64], *vals, *ends; 87292a61f64SAndi Kleen 87392a61f64SAndi Kleen if (unit == NULL || fmt == NULL) { 87492a61f64SAndi Kleen fprintf(out, "%s%s%s%s", csv_sep, csv_sep, csv_sep, csv_sep); 87592a61f64SAndi Kleen return; 87692a61f64SAndi Kleen } 87792a61f64SAndi Kleen snprintf(buf, sizeof(buf), fmt, val); 87892a61f64SAndi Kleen vals = buf; 87992a61f64SAndi Kleen while (isspace(*vals)) 88092a61f64SAndi Kleen vals++; 88192a61f64SAndi Kleen ends = vals; 88292a61f64SAndi Kleen while (isdigit(*ends) || *ends == '.') 88392a61f64SAndi Kleen ends++; 88492a61f64SAndi Kleen *ends = 0; 88592a61f64SAndi Kleen while (isspace(*unit)) 88692a61f64SAndi Kleen unit++; 88792a61f64SAndi Kleen fprintf(out, "%s%s%s%s", csv_sep, vals, csv_sep, unit); 88892a61f64SAndi Kleen } 88992a61f64SAndi Kleen 89054b50916SAndi Kleen #define METRIC_ONLY_LEN 20 89154b50916SAndi Kleen 89254b50916SAndi Kleen /* Filter out some columns that don't work well in metrics only mode */ 89354b50916SAndi Kleen 89454b50916SAndi Kleen static bool valid_only_metric(const char *unit) 89554b50916SAndi Kleen { 89654b50916SAndi Kleen if (!unit) 89754b50916SAndi Kleen return false; 89854b50916SAndi Kleen if (strstr(unit, "/sec") || 89954b50916SAndi Kleen strstr(unit, "hz") || 90054b50916SAndi Kleen strstr(unit, "Hz") || 90154b50916SAndi Kleen strstr(unit, "CPUs utilized")) 90254b50916SAndi Kleen return false; 90354b50916SAndi Kleen return true; 90454b50916SAndi Kleen } 90554b50916SAndi Kleen 90654b50916SAndi Kleen static const char *fixunit(char *buf, struct perf_evsel *evsel, 90754b50916SAndi Kleen const char *unit) 90854b50916SAndi Kleen { 90954b50916SAndi Kleen if (!strncmp(unit, "of all", 6)) { 91054b50916SAndi Kleen snprintf(buf, 1024, "%s %s", perf_evsel__name(evsel), 91154b50916SAndi Kleen unit); 91254b50916SAndi Kleen return buf; 91354b50916SAndi Kleen } 91454b50916SAndi Kleen return unit; 91554b50916SAndi Kleen } 91654b50916SAndi Kleen 91754b50916SAndi Kleen static void print_metric_only(void *ctx, const char *color, const char *fmt, 91854b50916SAndi Kleen const char *unit, double val) 91954b50916SAndi Kleen { 92054b50916SAndi Kleen struct outstate *os = ctx; 92154b50916SAndi Kleen FILE *out = os->fh; 92254b50916SAndi Kleen int n; 92354b50916SAndi Kleen char buf[1024]; 92454b50916SAndi Kleen unsigned mlen = METRIC_ONLY_LEN; 92554b50916SAndi Kleen 92654b50916SAndi Kleen if (!valid_only_metric(unit)) 92754b50916SAndi Kleen return; 92854b50916SAndi Kleen unit = fixunit(buf, os->evsel, unit); 92954b50916SAndi Kleen if (color) 93054b50916SAndi Kleen n = color_fprintf(out, color, fmt, val); 93154b50916SAndi Kleen else 93254b50916SAndi Kleen n = fprintf(out, fmt, val); 93354b50916SAndi Kleen if (n > METRIC_ONLY_LEN) 93454b50916SAndi Kleen n = METRIC_ONLY_LEN; 93554b50916SAndi Kleen if (mlen < strlen(unit)) 93654b50916SAndi Kleen mlen = strlen(unit) + 1; 93754b50916SAndi Kleen fprintf(out, "%*s", mlen - n, ""); 93854b50916SAndi Kleen } 93954b50916SAndi Kleen 94054b50916SAndi Kleen static void print_metric_only_csv(void *ctx, const char *color __maybe_unused, 94154b50916SAndi Kleen const char *fmt, 94254b50916SAndi Kleen const char *unit, double val) 94354b50916SAndi Kleen { 94454b50916SAndi Kleen struct outstate *os = ctx; 94554b50916SAndi Kleen FILE *out = os->fh; 94654b50916SAndi Kleen char buf[64], *vals, *ends; 94754b50916SAndi Kleen char tbuf[1024]; 94854b50916SAndi Kleen 94954b50916SAndi Kleen if (!valid_only_metric(unit)) 95054b50916SAndi Kleen return; 95154b50916SAndi Kleen unit = fixunit(tbuf, os->evsel, unit); 95254b50916SAndi Kleen snprintf(buf, sizeof buf, fmt, val); 95354b50916SAndi Kleen vals = buf; 95454b50916SAndi Kleen while (isspace(*vals)) 95554b50916SAndi Kleen vals++; 95654b50916SAndi Kleen ends = vals; 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; 1148140aeadcSAndi Kleen 114954b50916SAndi Kleen if (csv_output && !metric_only) { 115092a61f64SAndi Kleen print_noise(counter, noise); 115192a61f64SAndi Kleen print_running(run, ena); 115292a61f64SAndi Kleen } 115392a61f64SAndi Kleen 1154140aeadcSAndi Kleen perf_stat__print_shadow_stats(counter, uval, 115544d49a60SAndi Kleen first_shadow_cpu(counter, id), 1156140aeadcSAndi Kleen &out); 115754b50916SAndi Kleen if (!csv_output && !metric_only) { 1158cb110f47SAndi Kleen print_noise(counter, noise); 1159cb110f47SAndi Kleen print_running(run, ena); 1160556b1fb7SJiri Olsa } 116192a61f64SAndi Kleen } 1162556b1fb7SJiri Olsa 116344d49a60SAndi Kleen static void aggr_update_shadow(void) 116444d49a60SAndi Kleen { 116544d49a60SAndi Kleen int cpu, s2, id, s; 116644d49a60SAndi Kleen u64 val; 116744d49a60SAndi Kleen struct perf_evsel *counter; 116844d49a60SAndi Kleen 116944d49a60SAndi Kleen for (s = 0; s < aggr_map->nr; s++) { 117044d49a60SAndi Kleen id = aggr_map->map[s]; 1171e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 117244d49a60SAndi Kleen val = 0; 117344d49a60SAndi Kleen for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 117444d49a60SAndi Kleen s2 = aggr_get_id(evsel_list->cpus, cpu); 117544d49a60SAndi Kleen if (s2 != id) 117644d49a60SAndi Kleen continue; 117744d49a60SAndi Kleen val += perf_counts(counter->counts, cpu, 0)->val; 117844d49a60SAndi Kleen } 117944d49a60SAndi Kleen val = val * counter->scale; 118044d49a60SAndi Kleen perf_stat__update_shadow_stats(counter, &val, 118144d49a60SAndi Kleen first_shadow_cpu(counter, id)); 118244d49a60SAndi Kleen } 118344d49a60SAndi Kleen } 118444d49a60SAndi Kleen } 118544d49a60SAndi Kleen 1186430daf2dSAndi Kleen static void collect_all_aliases(struct perf_evsel *counter, 1187fbe51fbaSAndi Kleen void (*cb)(struct perf_evsel *counter, void *data, 1188fbe51fbaSAndi Kleen bool first), 1189fbe51fbaSAndi Kleen void *data) 1190fbe51fbaSAndi Kleen { 1191430daf2dSAndi Kleen struct perf_evsel *alias; 1192430daf2dSAndi Kleen 1193430daf2dSAndi Kleen alias = list_prepare_entry(counter, &(evsel_list->entries), node); 1194430daf2dSAndi Kleen list_for_each_entry_continue (alias, &evsel_list->entries, node) { 1195430daf2dSAndi Kleen if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) || 1196430daf2dSAndi Kleen alias->scale != counter->scale || 1197430daf2dSAndi Kleen alias->cgrp != counter->cgrp || 1198430daf2dSAndi Kleen strcmp(alias->unit, counter->unit) || 1199430daf2dSAndi Kleen nsec_counter(alias) != nsec_counter(counter)) 1200430daf2dSAndi Kleen break; 1201430daf2dSAndi Kleen alias->merged_stat = true; 1202430daf2dSAndi Kleen cb(alias, data, false); 1203430daf2dSAndi Kleen } 1204430daf2dSAndi Kleen } 1205430daf2dSAndi Kleen 1206430daf2dSAndi Kleen static bool collect_data(struct perf_evsel *counter, 1207430daf2dSAndi Kleen void (*cb)(struct perf_evsel *counter, void *data, 1208430daf2dSAndi Kleen bool first), 1209430daf2dSAndi Kleen void *data) 1210430daf2dSAndi Kleen { 1211430daf2dSAndi Kleen if (counter->merged_stat) 1212430daf2dSAndi Kleen return false; 1213fbe51fbaSAndi Kleen cb(counter, data, true); 1214430daf2dSAndi Kleen if (!no_merge) 1215430daf2dSAndi Kleen collect_all_aliases(counter, cb, data); 1216430daf2dSAndi Kleen return true; 1217fbe51fbaSAndi Kleen } 1218fbe51fbaSAndi Kleen 1219fbe51fbaSAndi Kleen struct aggr_data { 1220fbe51fbaSAndi Kleen u64 ena, run, val; 1221fbe51fbaSAndi Kleen int id; 1222fbe51fbaSAndi Kleen int nr; 1223fbe51fbaSAndi Kleen int cpu; 1224fbe51fbaSAndi Kleen }; 1225fbe51fbaSAndi Kleen 1226fbe51fbaSAndi Kleen static void aggr_cb(struct perf_evsel *counter, void *data, bool first) 1227fbe51fbaSAndi Kleen { 1228fbe51fbaSAndi Kleen struct aggr_data *ad = data; 1229fbe51fbaSAndi Kleen int cpu, s2; 1230fbe51fbaSAndi Kleen 1231fbe51fbaSAndi Kleen for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1232fbe51fbaSAndi Kleen struct perf_counts_values *counts; 1233fbe51fbaSAndi Kleen 1234fbe51fbaSAndi Kleen s2 = aggr_get_id(perf_evsel__cpus(counter), cpu); 1235fbe51fbaSAndi Kleen if (s2 != ad->id) 1236fbe51fbaSAndi Kleen continue; 1237fbe51fbaSAndi Kleen if (first) 1238fbe51fbaSAndi Kleen ad->nr++; 1239fbe51fbaSAndi Kleen counts = perf_counts(counter->counts, cpu, 0); 1240b4229e9dSAndi Kleen /* 1241b4229e9dSAndi Kleen * When any result is bad, make them all to give 1242b4229e9dSAndi Kleen * consistent output in interval mode. 1243b4229e9dSAndi Kleen */ 1244b4229e9dSAndi Kleen if (counts->ena == 0 || counts->run == 0 || 1245b4229e9dSAndi Kleen counter->counts->scaled == -1) { 1246b4229e9dSAndi Kleen ad->ena = 0; 1247b4229e9dSAndi Kleen ad->run = 0; 1248b4229e9dSAndi Kleen break; 1249b4229e9dSAndi Kleen } 1250fbe51fbaSAndi Kleen ad->val += counts->val; 1251fbe51fbaSAndi Kleen ad->ena += counts->ena; 1252fbe51fbaSAndi Kleen ad->run += counts->run; 1253fbe51fbaSAndi Kleen } 1254fbe51fbaSAndi Kleen } 1255fbe51fbaSAndi Kleen 125686ee6e18SStephane Eranian static void print_aggr(char *prefix) 1257d7e7a451SStephane Eranian { 12585821522eSJiri Olsa FILE *output = stat_config.output; 1259d7e7a451SStephane Eranian struct perf_evsel *counter; 1260fbe51fbaSAndi Kleen int s, id, nr; 1261410136f5SStephane Eranian double uval; 1262d7e7a451SStephane Eranian u64 ena, run, val; 126354b50916SAndi Kleen bool first; 1264d7e7a451SStephane Eranian 126586ee6e18SStephane Eranian if (!(aggr_map || aggr_get_id)) 1266d7e7a451SStephane Eranian return; 1267d7e7a451SStephane Eranian 126844d49a60SAndi Kleen aggr_update_shadow(); 126944d49a60SAndi Kleen 127054b50916SAndi Kleen /* 127154b50916SAndi Kleen * With metric_only everything is on a single line. 127254b50916SAndi Kleen * Without each counter has its own line. 127354b50916SAndi Kleen */ 127486ee6e18SStephane Eranian for (s = 0; s < aggr_map->nr; s++) { 1275fbe51fbaSAndi Kleen struct aggr_data ad; 127654b50916SAndi Kleen if (prefix && metric_only) 127754b50916SAndi Kleen fprintf(output, "%s", prefix); 127854b50916SAndi Kleen 1279fbe51fbaSAndi Kleen ad.id = id = aggr_map->map[s]; 128054b50916SAndi Kleen first = true; 1281e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 1282fbe51fbaSAndi Kleen ad.val = ad.ena = ad.run = 0; 1283fbe51fbaSAndi Kleen ad.nr = 0; 1284430daf2dSAndi Kleen if (!collect_data(counter, aggr_cb, &ad)) 1285430daf2dSAndi Kleen continue; 1286fbe51fbaSAndi Kleen nr = ad.nr; 1287fbe51fbaSAndi Kleen ena = ad.ena; 1288fbe51fbaSAndi Kleen run = ad.run; 1289fbe51fbaSAndi Kleen val = ad.val; 129054b50916SAndi Kleen if (first && metric_only) { 129154b50916SAndi Kleen first = false; 129254b50916SAndi Kleen aggr_printout(counter, id, nr); 129354b50916SAndi Kleen } 129454b50916SAndi Kleen if (prefix && !metric_only) 1295d7e7a451SStephane Eranian fprintf(output, "%s", prefix); 1296d7e7a451SStephane Eranian 1297410136f5SStephane Eranian uval = val * counter->scale; 1298cb110f47SAndi Kleen printout(id, nr, counter, uval, prefix, run, ena, 1.0); 129954b50916SAndi Kleen if (!metric_only) 1300d7e7a451SStephane Eranian fputc('\n', output); 1301d7e7a451SStephane Eranian } 130254b50916SAndi Kleen if (metric_only) 130354b50916SAndi Kleen fputc('\n', output); 1304d7e7a451SStephane Eranian } 1305d7e7a451SStephane Eranian } 1306d7e7a451SStephane Eranian 130732b8af82SJiri Olsa static void print_aggr_thread(struct perf_evsel *counter, char *prefix) 130832b8af82SJiri Olsa { 13095821522eSJiri Olsa FILE *output = stat_config.output; 131032b8af82SJiri Olsa int nthreads = thread_map__nr(counter->threads); 131132b8af82SJiri Olsa int ncpus = cpu_map__nr(counter->cpus); 131232b8af82SJiri Olsa int cpu, thread; 131332b8af82SJiri Olsa double uval; 131432b8af82SJiri Olsa 131532b8af82SJiri Olsa for (thread = 0; thread < nthreads; thread++) { 131632b8af82SJiri Olsa u64 ena = 0, run = 0, val = 0; 131732b8af82SJiri Olsa 131832b8af82SJiri Olsa for (cpu = 0; cpu < ncpus; cpu++) { 131932b8af82SJiri Olsa val += perf_counts(counter->counts, cpu, thread)->val; 132032b8af82SJiri Olsa ena += perf_counts(counter->counts, cpu, thread)->ena; 132132b8af82SJiri Olsa run += perf_counts(counter->counts, cpu, thread)->run; 132232b8af82SJiri Olsa } 132332b8af82SJiri Olsa 132432b8af82SJiri Olsa if (prefix) 132532b8af82SJiri Olsa fprintf(output, "%s", prefix); 132632b8af82SJiri Olsa 132732b8af82SJiri Olsa uval = val * counter->scale; 1328cb110f47SAndi Kleen printout(thread, 0, counter, uval, prefix, run, ena, 1.0); 132932b8af82SJiri Olsa fputc('\n', output); 133032b8af82SJiri Olsa } 133132b8af82SJiri Olsa } 133232b8af82SJiri Olsa 1333fbe51fbaSAndi Kleen struct caggr_data { 1334fbe51fbaSAndi Kleen double avg, avg_enabled, avg_running; 1335fbe51fbaSAndi Kleen }; 1336fbe51fbaSAndi Kleen 1337fbe51fbaSAndi Kleen static void counter_aggr_cb(struct perf_evsel *counter, void *data, 1338fbe51fbaSAndi Kleen bool first __maybe_unused) 1339fbe51fbaSAndi Kleen { 1340fbe51fbaSAndi Kleen struct caggr_data *cd = data; 1341fbe51fbaSAndi Kleen struct perf_stat_evsel *ps = counter->priv; 1342fbe51fbaSAndi Kleen 1343fbe51fbaSAndi Kleen cd->avg += avg_stats(&ps->res_stats[0]); 1344fbe51fbaSAndi Kleen cd->avg_enabled += avg_stats(&ps->res_stats[1]); 1345fbe51fbaSAndi Kleen cd->avg_running += avg_stats(&ps->res_stats[2]); 1346fbe51fbaSAndi Kleen } 1347fbe51fbaSAndi Kleen 134842202dd5SIngo Molnar /* 134942202dd5SIngo Molnar * Print out the results of a single counter: 1350f5b4a9c3SStephane Eranian * aggregated counts in system-wide mode 135142202dd5SIngo Molnar */ 135213370a9bSStephane Eranian static void print_counter_aggr(struct perf_evsel *counter, char *prefix) 135342202dd5SIngo Molnar { 13545821522eSJiri Olsa FILE *output = stat_config.output; 1355410136f5SStephane Eranian double uval; 1356fbe51fbaSAndi Kleen struct caggr_data cd = { .avg = 0.0 }; 1357d73515c0SAndi Kleen 1358430daf2dSAndi Kleen if (!collect_data(counter, counter_aggr_cb, &cd)) 1359430daf2dSAndi Kleen return; 136042202dd5SIngo Molnar 136154b50916SAndi Kleen if (prefix && !metric_only) 136213370a9bSStephane Eranian fprintf(output, "%s", prefix); 136313370a9bSStephane Eranian 1364fbe51fbaSAndi Kleen uval = cd.avg * counter->scale; 1365fbe51fbaSAndi Kleen printout(-1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled, cd.avg); 136654b50916SAndi Kleen if (!metric_only) 13674aa9015fSStephane Eranian fprintf(output, "\n"); 136842202dd5SIngo Molnar } 136942202dd5SIngo Molnar 1370fbe51fbaSAndi Kleen static void counter_cb(struct perf_evsel *counter, void *data, 1371fbe51fbaSAndi Kleen bool first __maybe_unused) 1372fbe51fbaSAndi Kleen { 1373fbe51fbaSAndi Kleen struct aggr_data *ad = data; 1374fbe51fbaSAndi Kleen 1375fbe51fbaSAndi Kleen ad->val += perf_counts(counter->counts, ad->cpu, 0)->val; 1376fbe51fbaSAndi Kleen ad->ena += perf_counts(counter->counts, ad->cpu, 0)->ena; 1377fbe51fbaSAndi Kleen ad->run += perf_counts(counter->counts, ad->cpu, 0)->run; 1378fbe51fbaSAndi Kleen } 1379fbe51fbaSAndi Kleen 1380f5b4a9c3SStephane Eranian /* 1381f5b4a9c3SStephane Eranian * Print out the results of a single counter: 1382f5b4a9c3SStephane Eranian * does not use aggregated count in system-wide 1383f5b4a9c3SStephane Eranian */ 138413370a9bSStephane Eranian static void print_counter(struct perf_evsel *counter, char *prefix) 1385f5b4a9c3SStephane Eranian { 13865821522eSJiri Olsa FILE *output = stat_config.output; 1387f5b4a9c3SStephane Eranian u64 ena, run, val; 1388410136f5SStephane Eranian double uval; 1389f5b4a9c3SStephane Eranian int cpu; 1390f5b4a9c3SStephane Eranian 13917ae92e74SYan, Zheng for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1392fbe51fbaSAndi Kleen struct aggr_data ad = { .cpu = cpu }; 1393fbe51fbaSAndi Kleen 1394430daf2dSAndi Kleen if (!collect_data(counter, counter_cb, &ad)) 1395430daf2dSAndi Kleen return; 1396fbe51fbaSAndi Kleen val = ad.val; 1397fbe51fbaSAndi Kleen ena = ad.ena; 1398fbe51fbaSAndi Kleen run = ad.run; 139913370a9bSStephane Eranian 140013370a9bSStephane Eranian if (prefix) 140113370a9bSStephane Eranian fprintf(output, "%s", prefix); 140213370a9bSStephane Eranian 1403410136f5SStephane Eranian uval = val * counter->scale; 1404cb110f47SAndi Kleen printout(cpu, 0, counter, uval, prefix, run, ena, 1.0); 1405f5b4a9c3SStephane Eranian 14064aa9015fSStephane Eranian fputc('\n', output); 1407f5b4a9c3SStephane Eranian } 1408f5b4a9c3SStephane Eranian } 1409f5b4a9c3SStephane Eranian 1410206cab65SAndi Kleen static void print_no_aggr_metric(char *prefix) 1411206cab65SAndi Kleen { 1412206cab65SAndi Kleen int cpu; 1413206cab65SAndi Kleen int nrcpus = 0; 1414206cab65SAndi Kleen struct perf_evsel *counter; 1415206cab65SAndi Kleen u64 ena, run, val; 1416206cab65SAndi Kleen double uval; 1417206cab65SAndi Kleen 1418206cab65SAndi Kleen nrcpus = evsel_list->cpus->nr; 1419206cab65SAndi Kleen for (cpu = 0; cpu < nrcpus; cpu++) { 1420206cab65SAndi Kleen bool first = true; 1421206cab65SAndi Kleen 1422206cab65SAndi Kleen if (prefix) 1423206cab65SAndi Kleen fputs(prefix, stat_config.output); 1424e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 1425206cab65SAndi Kleen if (first) { 1426206cab65SAndi Kleen aggr_printout(counter, cpu, 0); 1427206cab65SAndi Kleen first = false; 1428206cab65SAndi Kleen } 1429206cab65SAndi Kleen val = perf_counts(counter->counts, cpu, 0)->val; 1430206cab65SAndi Kleen ena = perf_counts(counter->counts, cpu, 0)->ena; 1431206cab65SAndi Kleen run = perf_counts(counter->counts, cpu, 0)->run; 1432206cab65SAndi Kleen 1433206cab65SAndi Kleen uval = val * counter->scale; 1434206cab65SAndi Kleen printout(cpu, 0, counter, uval, prefix, run, ena, 1.0); 1435206cab65SAndi Kleen } 1436206cab65SAndi Kleen fputc('\n', stat_config.output); 1437206cab65SAndi Kleen } 1438206cab65SAndi Kleen } 1439206cab65SAndi Kleen 144054b50916SAndi Kleen static int aggr_header_lens[] = { 144154b50916SAndi Kleen [AGGR_CORE] = 18, 144254b50916SAndi Kleen [AGGR_SOCKET] = 12, 1443206cab65SAndi Kleen [AGGR_NONE] = 6, 144454b50916SAndi Kleen [AGGR_THREAD] = 24, 144554b50916SAndi Kleen [AGGR_GLOBAL] = 0, 144654b50916SAndi Kleen }; 144754b50916SAndi Kleen 1448c51fd639SAndi Kleen static const char *aggr_header_csv[] = { 1449c51fd639SAndi Kleen [AGGR_CORE] = "core,cpus,", 1450c51fd639SAndi Kleen [AGGR_SOCKET] = "socket,cpus", 1451c51fd639SAndi Kleen [AGGR_NONE] = "cpu,", 1452c51fd639SAndi Kleen [AGGR_THREAD] = "comm-pid,", 1453c51fd639SAndi Kleen [AGGR_GLOBAL] = "" 1454c51fd639SAndi Kleen }; 1455c51fd639SAndi Kleen 145641c8ca2aSAndi Kleen static void print_metric_headers(const char *prefix, bool no_indent) 145754b50916SAndi Kleen { 145854b50916SAndi Kleen struct perf_stat_output_ctx out; 145954b50916SAndi Kleen struct perf_evsel *counter; 146054b50916SAndi Kleen struct outstate os = { 146154b50916SAndi Kleen .fh = stat_config.output 146254b50916SAndi Kleen }; 146354b50916SAndi Kleen 146454b50916SAndi Kleen if (prefix) 146554b50916SAndi Kleen fprintf(stat_config.output, "%s", prefix); 146654b50916SAndi Kleen 146741c8ca2aSAndi Kleen if (!csv_output && !no_indent) 146854b50916SAndi Kleen fprintf(stat_config.output, "%*s", 146954b50916SAndi Kleen aggr_header_lens[stat_config.aggr_mode], ""); 1470c51fd639SAndi Kleen if (csv_output) { 1471c51fd639SAndi Kleen if (stat_config.interval) 1472c51fd639SAndi Kleen fputs("time,", stat_config.output); 1473c51fd639SAndi Kleen fputs(aggr_header_csv[stat_config.aggr_mode], 1474c51fd639SAndi Kleen stat_config.output); 1475c51fd639SAndi Kleen } 147654b50916SAndi Kleen 147754b50916SAndi Kleen /* Print metrics headers only */ 1478e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) { 147954b50916SAndi Kleen os.evsel = counter; 148054b50916SAndi Kleen out.ctx = &os; 148154b50916SAndi Kleen out.print_metric = print_metric_header; 148254b50916SAndi Kleen out.new_line = new_line_metric; 148354b50916SAndi Kleen os.evsel = counter; 148454b50916SAndi Kleen perf_stat__print_shadow_stats(counter, 0, 148554b50916SAndi Kleen 0, 148654b50916SAndi Kleen &out); 148754b50916SAndi Kleen } 148854b50916SAndi Kleen fputc('\n', stat_config.output); 148954b50916SAndi Kleen } 149054b50916SAndi Kleen 1491d4f63a47SJiri Olsa static void print_interval(char *prefix, struct timespec *ts) 149242202dd5SIngo Molnar { 14935821522eSJiri Olsa FILE *output = stat_config.output; 1494d4f63a47SJiri Olsa static int num_print_interval; 1495d4f63a47SJiri Olsa 1496d4f63a47SJiri Olsa sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, csv_sep); 1497d4f63a47SJiri Olsa 149841c8ca2aSAndi Kleen if (num_print_interval == 0 && !csv_output) { 1499421a50f3SJiri Olsa switch (stat_config.aggr_mode) { 1500d4f63a47SJiri Olsa case AGGR_SOCKET: 150141c8ca2aSAndi Kleen fprintf(output, "# time socket cpus"); 150241c8ca2aSAndi Kleen if (!metric_only) 150341c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 1504d4f63a47SJiri Olsa break; 1505d4f63a47SJiri Olsa case AGGR_CORE: 150641c8ca2aSAndi Kleen fprintf(output, "# time core cpus"); 150741c8ca2aSAndi Kleen if (!metric_only) 150841c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 1509d4f63a47SJiri Olsa break; 1510d4f63a47SJiri Olsa case AGGR_NONE: 151141c8ca2aSAndi Kleen fprintf(output, "# time CPU"); 151241c8ca2aSAndi Kleen if (!metric_only) 151341c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 1514d4f63a47SJiri Olsa break; 151532b8af82SJiri Olsa case AGGR_THREAD: 151641c8ca2aSAndi Kleen fprintf(output, "# time comm-pid"); 151741c8ca2aSAndi Kleen if (!metric_only) 151841c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 151932b8af82SJiri Olsa break; 1520d4f63a47SJiri Olsa case AGGR_GLOBAL: 1521d4f63a47SJiri Olsa default: 152241c8ca2aSAndi Kleen fprintf(output, "# time"); 152341c8ca2aSAndi Kleen if (!metric_only) 152441c8ca2aSAndi Kleen fprintf(output, " counts %*s events\n", unit_width, "unit"); 1525208df99eSJiri Olsa case AGGR_UNSET: 1526208df99eSJiri Olsa break; 1527d4f63a47SJiri Olsa } 1528d4f63a47SJiri Olsa } 1529d4f63a47SJiri Olsa 153041c8ca2aSAndi Kleen if (num_print_interval == 0 && metric_only) 153141c8ca2aSAndi Kleen print_metric_headers(" ", true); 1532d4f63a47SJiri Olsa if (++num_print_interval == 25) 1533d4f63a47SJiri Olsa num_print_interval = 0; 1534d4f63a47SJiri Olsa } 1535d4f63a47SJiri Olsa 1536d4f63a47SJiri Olsa static void print_header(int argc, const char **argv) 1537d4f63a47SJiri Olsa { 15385821522eSJiri Olsa FILE *output = stat_config.output; 153969aad6f1SArnaldo Carvalho de Melo int i; 154042202dd5SIngo Molnar 154186470930SIngo Molnar fflush(stdout); 154286470930SIngo Molnar 1543d7470b6aSStephane Eranian if (!csv_output) { 15444aa9015fSStephane Eranian fprintf(output, "\n"); 15454aa9015fSStephane Eranian fprintf(output, " Performance counter stats for "); 154662d3b617SDavid Ahern if (target.system_wide) 154762d3b617SDavid Ahern fprintf(output, "\'system wide"); 154862d3b617SDavid Ahern else if (target.cpu_list) 154962d3b617SDavid Ahern fprintf(output, "\'CPU(s) %s", target.cpu_list); 1550602ad878SArnaldo Carvalho de Melo else if (!target__has_task(&target)) { 1551ba6039b6SJiri Olsa fprintf(output, "\'%s", argv ? argv[0] : "pipe"); 1552ba6039b6SJiri Olsa for (i = 1; argv && (i < argc); i++) 15534aa9015fSStephane Eranian fprintf(output, " %s", argv[i]); 155420f946b4SNamhyung Kim } else if (target.pid) 155520f946b4SNamhyung Kim fprintf(output, "process id \'%s", target.pid); 1556d6d901c2SZhang, Yanmin else 155720f946b4SNamhyung Kim fprintf(output, "thread id \'%s", target.tid); 155886470930SIngo Molnar 15594aa9015fSStephane Eranian fprintf(output, "\'"); 156042202dd5SIngo Molnar if (run_count > 1) 15614aa9015fSStephane Eranian fprintf(output, " (%d runs)", run_count); 15624aa9015fSStephane Eranian fprintf(output, ":\n\n"); 1563d7470b6aSStephane Eranian } 1564f5b4a9c3SStephane Eranian } 156586470930SIngo Molnar 1566d4f63a47SJiri Olsa static void print_footer(void) 1567d4f63a47SJiri Olsa { 15685821522eSJiri Olsa FILE *output = stat_config.output; 15695821522eSJiri Olsa 1570c3305257SIngo Molnar if (!null_run) 15714aa9015fSStephane Eranian fprintf(output, "\n"); 15724aa9015fSStephane Eranian fprintf(output, " %17.9f seconds time elapsed", 1573310ebb93SArnaldo Carvalho de Melo avg_stats(&walltime_nsecs_stats) / NSEC_PER_SEC); 1574566747e6SIngo Molnar if (run_count > 1) { 15754aa9015fSStephane Eranian fprintf(output, " "); 1576f99844cbSIngo Molnar print_noise_pct(stddev_stats(&walltime_nsecs_stats), 1577506d4bc8SPeter Zijlstra avg_stats(&walltime_nsecs_stats)); 1578566747e6SIngo Molnar } 15794aa9015fSStephane Eranian fprintf(output, "\n\n"); 158002d492e5SBorislav Petkov 158102d492e5SBorislav Petkov if (print_free_counters_hint) 158202d492e5SBorislav Petkov fprintf(output, 158302d492e5SBorislav Petkov "Some events weren't counted. Try disabling the NMI watchdog:\n" 158402d492e5SBorislav Petkov " echo 0 > /proc/sys/kernel/nmi_watchdog\n" 158502d492e5SBorislav Petkov " perf stat ...\n" 158602d492e5SBorislav Petkov " echo 1 > /proc/sys/kernel/nmi_watchdog\n"); 158786470930SIngo Molnar } 1588d4f63a47SJiri Olsa 1589d4f63a47SJiri Olsa static void print_counters(struct timespec *ts, int argc, const char **argv) 1590d4f63a47SJiri Olsa { 1591ec0d3d1fSJiri Olsa int interval = stat_config.interval; 1592d4f63a47SJiri Olsa struct perf_evsel *counter; 1593d4f63a47SJiri Olsa char buf[64], *prefix = NULL; 1594d4f63a47SJiri Olsa 1595664c98d4SJiri Olsa /* Do not print anything if we record to the pipe. */ 1596664c98d4SJiri Olsa if (STAT_RECORD && perf_stat.file.is_pipe) 1597664c98d4SJiri Olsa return; 1598664c98d4SJiri Olsa 1599d4f63a47SJiri Olsa if (interval) 1600d4f63a47SJiri Olsa print_interval(prefix = buf, ts); 1601d4f63a47SJiri Olsa else 1602d4f63a47SJiri Olsa print_header(argc, argv); 1603d4f63a47SJiri Olsa 160454b50916SAndi Kleen if (metric_only) { 160554b50916SAndi Kleen static int num_print_iv; 160654b50916SAndi Kleen 160741c8ca2aSAndi Kleen if (num_print_iv == 0 && !interval) 160841c8ca2aSAndi Kleen print_metric_headers(prefix, false); 160954b50916SAndi Kleen if (num_print_iv++ == 25) 161054b50916SAndi Kleen num_print_iv = 0; 161154b50916SAndi Kleen if (stat_config.aggr_mode == AGGR_GLOBAL && prefix) 161254b50916SAndi Kleen fprintf(stat_config.output, "%s", prefix); 161354b50916SAndi Kleen } 161454b50916SAndi Kleen 1615421a50f3SJiri Olsa switch (stat_config.aggr_mode) { 1616d4f63a47SJiri Olsa case AGGR_CORE: 1617d4f63a47SJiri Olsa case AGGR_SOCKET: 1618d4f63a47SJiri Olsa print_aggr(prefix); 1619d4f63a47SJiri Olsa break; 162032b8af82SJiri Olsa case AGGR_THREAD: 1621e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) 162232b8af82SJiri Olsa print_aggr_thread(counter, prefix); 162332b8af82SJiri Olsa break; 1624d4f63a47SJiri Olsa case AGGR_GLOBAL: 1625e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) 1626d4f63a47SJiri Olsa print_counter_aggr(counter, prefix); 162754b50916SAndi Kleen if (metric_only) 162854b50916SAndi Kleen fputc('\n', stat_config.output); 1629d4f63a47SJiri Olsa break; 1630d4f63a47SJiri Olsa case AGGR_NONE: 1631206cab65SAndi Kleen if (metric_only) 1632206cab65SAndi Kleen print_no_aggr_metric(prefix); 1633206cab65SAndi Kleen else { 1634e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) 1635d4f63a47SJiri Olsa print_counter(counter, prefix); 1636206cab65SAndi Kleen } 1637d4f63a47SJiri Olsa break; 1638208df99eSJiri Olsa case AGGR_UNSET: 1639d4f63a47SJiri Olsa default: 1640d4f63a47SJiri Olsa break; 1641d4f63a47SJiri Olsa } 1642d4f63a47SJiri Olsa 1643d4f63a47SJiri Olsa if (!interval && !csv_output) 1644d4f63a47SJiri Olsa print_footer(); 1645d4f63a47SJiri Olsa 16465821522eSJiri Olsa fflush(stat_config.output); 1647d7470b6aSStephane Eranian } 164886470930SIngo Molnar 1649f7b7c26eSPeter Zijlstra static volatile int signr = -1; 1650f7b7c26eSPeter Zijlstra 165186470930SIngo Molnar static void skip_signal(int signo) 165286470930SIngo Molnar { 1653ec0d3d1fSJiri Olsa if ((child_pid == -1) || stat_config.interval) 165460666c63SLiming Wang done = 1; 165560666c63SLiming Wang 1656f7b7c26eSPeter Zijlstra signr = signo; 1657d07f0b12SStephane Eranian /* 1658d07f0b12SStephane Eranian * render child_pid harmless 1659d07f0b12SStephane Eranian * won't send SIGTERM to a random 1660d07f0b12SStephane Eranian * process in case of race condition 1661d07f0b12SStephane Eranian * and fast PID recycling 1662d07f0b12SStephane Eranian */ 1663d07f0b12SStephane Eranian child_pid = -1; 1664f7b7c26eSPeter Zijlstra } 1665f7b7c26eSPeter Zijlstra 1666f7b7c26eSPeter Zijlstra static void sig_atexit(void) 1667f7b7c26eSPeter Zijlstra { 1668d07f0b12SStephane Eranian sigset_t set, oset; 1669d07f0b12SStephane Eranian 1670d07f0b12SStephane Eranian /* 1671d07f0b12SStephane Eranian * avoid race condition with SIGCHLD handler 1672d07f0b12SStephane Eranian * in skip_signal() which is modifying child_pid 1673d07f0b12SStephane Eranian * goal is to avoid send SIGTERM to a random 1674d07f0b12SStephane Eranian * process 1675d07f0b12SStephane Eranian */ 1676d07f0b12SStephane Eranian sigemptyset(&set); 1677d07f0b12SStephane Eranian sigaddset(&set, SIGCHLD); 1678d07f0b12SStephane Eranian sigprocmask(SIG_BLOCK, &set, &oset); 1679d07f0b12SStephane Eranian 1680933da83aSChris Wilson if (child_pid != -1) 1681933da83aSChris Wilson kill(child_pid, SIGTERM); 1682933da83aSChris Wilson 1683d07f0b12SStephane Eranian sigprocmask(SIG_SETMASK, &oset, NULL); 1684d07f0b12SStephane Eranian 1685f7b7c26eSPeter Zijlstra if (signr == -1) 1686f7b7c26eSPeter Zijlstra return; 1687f7b7c26eSPeter Zijlstra 1688f7b7c26eSPeter Zijlstra signal(signr, SIG_DFL); 1689f7b7c26eSPeter Zijlstra kill(getpid(), signr); 169086470930SIngo Molnar } 169186470930SIngo Molnar 16921d037ca1SIrina Tirdea static int stat__set_big_num(const struct option *opt __maybe_unused, 16931d037ca1SIrina Tirdea const char *s __maybe_unused, int unset) 1694d7470b6aSStephane Eranian { 1695d7470b6aSStephane Eranian big_num_opt = unset ? 0 : 1; 1696d7470b6aSStephane Eranian return 0; 1697d7470b6aSStephane Eranian } 1698d7470b6aSStephane Eranian 169944b1e60aSAndi Kleen static int enable_metric_only(const struct option *opt __maybe_unused, 170044b1e60aSAndi Kleen const char *s __maybe_unused, int unset) 170144b1e60aSAndi Kleen { 170244b1e60aSAndi Kleen force_metric_only = true; 170344b1e60aSAndi Kleen metric_only = !unset; 170444b1e60aSAndi Kleen return 0; 170544b1e60aSAndi Kleen } 170644b1e60aSAndi Kleen 1707e0547311SJiri Olsa static const struct option stat_options[] = { 1708e0547311SJiri Olsa OPT_BOOLEAN('T', "transaction", &transaction_run, 1709e0547311SJiri Olsa "hardware transaction statistics"), 1710e0547311SJiri Olsa OPT_CALLBACK('e', "event", &evsel_list, "event", 1711e0547311SJiri Olsa "event selector. use 'perf list' to list available events", 1712e0547311SJiri Olsa parse_events_option), 1713e0547311SJiri Olsa OPT_CALLBACK(0, "filter", &evsel_list, "filter", 1714e0547311SJiri Olsa "event filter", parse_filter), 1715e0547311SJiri Olsa OPT_BOOLEAN('i', "no-inherit", &no_inherit, 1716e0547311SJiri Olsa "child tasks do not inherit counters"), 1717e0547311SJiri Olsa OPT_STRING('p', "pid", &target.pid, "pid", 1718e0547311SJiri Olsa "stat events on existing process id"), 1719e0547311SJiri Olsa OPT_STRING('t', "tid", &target.tid, "tid", 1720e0547311SJiri Olsa "stat events on existing thread id"), 1721e0547311SJiri Olsa OPT_BOOLEAN('a', "all-cpus", &target.system_wide, 1722e0547311SJiri Olsa "system-wide collection from all CPUs"), 1723e0547311SJiri Olsa OPT_BOOLEAN('g', "group", &group, 1724e0547311SJiri Olsa "put the counters into a counter group"), 1725e0547311SJiri Olsa OPT_BOOLEAN('c', "scale", &stat_config.scale, "scale/normalize counters"), 1726e0547311SJiri Olsa OPT_INCR('v', "verbose", &verbose, 1727e0547311SJiri Olsa "be more verbose (show counter open errors, etc)"), 1728e0547311SJiri Olsa OPT_INTEGER('r', "repeat", &run_count, 1729e0547311SJiri Olsa "repeat command and print average + stddev (max: 100, forever: 0)"), 1730e0547311SJiri Olsa OPT_BOOLEAN('n', "null", &null_run, 1731e0547311SJiri Olsa "null run - dont start any counters"), 1732e0547311SJiri Olsa OPT_INCR('d', "detailed", &detailed_run, 1733e0547311SJiri Olsa "detailed run - start a lot of events"), 1734e0547311SJiri Olsa OPT_BOOLEAN('S', "sync", &sync_run, 1735e0547311SJiri Olsa "call sync() before starting a run"), 1736e0547311SJiri Olsa OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 1737e0547311SJiri Olsa "print large numbers with thousands\' separators", 1738e0547311SJiri Olsa stat__set_big_num), 1739e0547311SJiri Olsa OPT_STRING('C', "cpu", &target.cpu_list, "cpu", 1740e0547311SJiri Olsa "list of cpus to monitor in system-wide"), 1741e0547311SJiri Olsa OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode, 1742e0547311SJiri Olsa "disable CPU count aggregation", AGGR_NONE), 1743430daf2dSAndi Kleen OPT_BOOLEAN(0, "no-merge", &no_merge, "Do not merge identical named events"), 1744e0547311SJiri Olsa OPT_STRING('x', "field-separator", &csv_sep, "separator", 1745e0547311SJiri Olsa "print counts with custom separator"), 1746e0547311SJiri Olsa OPT_CALLBACK('G', "cgroup", &evsel_list, "name", 1747e0547311SJiri Olsa "monitor event in cgroup name only", parse_cgroups), 1748e0547311SJiri Olsa OPT_STRING('o', "output", &output_name, "file", "output file name"), 1749e0547311SJiri Olsa OPT_BOOLEAN(0, "append", &append_file, "append to the output file"), 1750e0547311SJiri Olsa OPT_INTEGER(0, "log-fd", &output_fd, 1751e0547311SJiri Olsa "log output to fd, instead of stderr"), 1752e0547311SJiri Olsa OPT_STRING(0, "pre", &pre_cmd, "command", 1753e0547311SJiri Olsa "command to run prior to the measured command"), 1754e0547311SJiri Olsa OPT_STRING(0, "post", &post_cmd, "command", 1755e0547311SJiri Olsa "command to run after to the measured command"), 1756e0547311SJiri Olsa OPT_UINTEGER('I', "interval-print", &stat_config.interval, 1757e0547311SJiri Olsa "print counts at regular interval in ms (>= 10)"), 1758e0547311SJiri Olsa OPT_SET_UINT(0, "per-socket", &stat_config.aggr_mode, 1759e0547311SJiri Olsa "aggregate counts per processor socket", AGGR_SOCKET), 1760e0547311SJiri Olsa OPT_SET_UINT(0, "per-core", &stat_config.aggr_mode, 1761e0547311SJiri Olsa "aggregate counts per physical processor core", AGGR_CORE), 1762e0547311SJiri Olsa OPT_SET_UINT(0, "per-thread", &stat_config.aggr_mode, 1763e0547311SJiri Olsa "aggregate counts per thread", AGGR_THREAD), 1764e0547311SJiri Olsa OPT_UINTEGER('D', "delay", &initial_delay, 1765e0547311SJiri Olsa "ms to wait before starting measurement after program start"), 176644b1e60aSAndi Kleen OPT_CALLBACK_NOOPT(0, "metric-only", &metric_only, NULL, 176744b1e60aSAndi Kleen "Only print computed metrics. No raw values", enable_metric_only), 176844b1e60aSAndi Kleen OPT_BOOLEAN(0, "topdown", &topdown_run, 176944b1e60aSAndi Kleen "measure topdown level 1 statistics"), 1770e0547311SJiri Olsa OPT_END() 1771e0547311SJiri Olsa }; 1772e0547311SJiri Olsa 17731fe7a300SJiri Olsa static int perf_stat__get_socket(struct cpu_map *map, int cpu) 17741fe7a300SJiri Olsa { 17751fe7a300SJiri Olsa return cpu_map__get_socket(map, cpu, NULL); 17761fe7a300SJiri Olsa } 17771fe7a300SJiri Olsa 17781fe7a300SJiri Olsa static int perf_stat__get_core(struct cpu_map *map, int cpu) 17791fe7a300SJiri Olsa { 17801fe7a300SJiri Olsa return cpu_map__get_core(map, cpu, NULL); 17811fe7a300SJiri Olsa } 17821fe7a300SJiri Olsa 17831e5a2931SJiri Olsa static int cpu_map__get_max(struct cpu_map *map) 17841e5a2931SJiri Olsa { 17851e5a2931SJiri Olsa int i, max = -1; 17861e5a2931SJiri Olsa 17871e5a2931SJiri Olsa for (i = 0; i < map->nr; i++) { 17881e5a2931SJiri Olsa if (map->map[i] > max) 17891e5a2931SJiri Olsa max = map->map[i]; 17901e5a2931SJiri Olsa } 17911e5a2931SJiri Olsa 17921e5a2931SJiri Olsa return max; 17931e5a2931SJiri Olsa } 17941e5a2931SJiri Olsa 17951e5a2931SJiri Olsa static struct cpu_map *cpus_aggr_map; 17961e5a2931SJiri Olsa 17971e5a2931SJiri Olsa static int perf_stat__get_aggr(aggr_get_id_t get_id, struct cpu_map *map, int idx) 17981e5a2931SJiri Olsa { 17991e5a2931SJiri Olsa int cpu; 18001e5a2931SJiri Olsa 18011e5a2931SJiri Olsa if (idx >= map->nr) 18021e5a2931SJiri Olsa return -1; 18031e5a2931SJiri Olsa 18041e5a2931SJiri Olsa cpu = map->map[idx]; 18051e5a2931SJiri Olsa 18061e5a2931SJiri Olsa if (cpus_aggr_map->map[cpu] == -1) 18071e5a2931SJiri Olsa cpus_aggr_map->map[cpu] = get_id(map, idx); 18081e5a2931SJiri Olsa 18091e5a2931SJiri Olsa return cpus_aggr_map->map[cpu]; 18101e5a2931SJiri Olsa } 18111e5a2931SJiri Olsa 18121e5a2931SJiri Olsa static int perf_stat__get_socket_cached(struct cpu_map *map, int idx) 18131e5a2931SJiri Olsa { 18141e5a2931SJiri Olsa return perf_stat__get_aggr(perf_stat__get_socket, map, idx); 18151e5a2931SJiri Olsa } 18161e5a2931SJiri Olsa 18171e5a2931SJiri Olsa static int perf_stat__get_core_cached(struct cpu_map *map, int idx) 18181e5a2931SJiri Olsa { 18191e5a2931SJiri Olsa return perf_stat__get_aggr(perf_stat__get_core, map, idx); 18201e5a2931SJiri Olsa } 18211e5a2931SJiri Olsa 182286ee6e18SStephane Eranian static int perf_stat_init_aggr_mode(void) 182386ee6e18SStephane Eranian { 18241e5a2931SJiri Olsa int nr; 18251e5a2931SJiri Olsa 1826421a50f3SJiri Olsa switch (stat_config.aggr_mode) { 182786ee6e18SStephane Eranian case AGGR_SOCKET: 182886ee6e18SStephane Eranian if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) { 182986ee6e18SStephane Eranian perror("cannot build socket map"); 183086ee6e18SStephane Eranian return -1; 183186ee6e18SStephane Eranian } 18321e5a2931SJiri Olsa aggr_get_id = perf_stat__get_socket_cached; 183386ee6e18SStephane Eranian break; 183412c08a9fSStephane Eranian case AGGR_CORE: 183512c08a9fSStephane Eranian if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) { 183612c08a9fSStephane Eranian perror("cannot build core map"); 183712c08a9fSStephane Eranian return -1; 183812c08a9fSStephane Eranian } 18391e5a2931SJiri Olsa aggr_get_id = perf_stat__get_core_cached; 184012c08a9fSStephane Eranian break; 184186ee6e18SStephane Eranian case AGGR_NONE: 184286ee6e18SStephane Eranian case AGGR_GLOBAL: 184332b8af82SJiri Olsa case AGGR_THREAD: 1844208df99eSJiri Olsa case AGGR_UNSET: 184586ee6e18SStephane Eranian default: 184686ee6e18SStephane Eranian break; 184786ee6e18SStephane Eranian } 18481e5a2931SJiri Olsa 18491e5a2931SJiri Olsa /* 18501e5a2931SJiri Olsa * The evsel_list->cpus is the base we operate on, 18511e5a2931SJiri Olsa * taking the highest cpu number to be the size of 18521e5a2931SJiri Olsa * the aggregation translate cpumap. 18531e5a2931SJiri Olsa */ 18541e5a2931SJiri Olsa nr = cpu_map__get_max(evsel_list->cpus); 18551e5a2931SJiri Olsa cpus_aggr_map = cpu_map__empty_new(nr + 1); 18561e5a2931SJiri Olsa return cpus_aggr_map ? 0 : -ENOMEM; 185786ee6e18SStephane Eranian } 185886ee6e18SStephane Eranian 1859544c2ae7SMasami Hiramatsu static void perf_stat__exit_aggr_mode(void) 1860544c2ae7SMasami Hiramatsu { 1861544c2ae7SMasami Hiramatsu cpu_map__put(aggr_map); 1862544c2ae7SMasami Hiramatsu cpu_map__put(cpus_aggr_map); 1863544c2ae7SMasami Hiramatsu aggr_map = NULL; 1864544c2ae7SMasami Hiramatsu cpus_aggr_map = NULL; 1865544c2ae7SMasami Hiramatsu } 1866544c2ae7SMasami Hiramatsu 186768d702f7SJiri Olsa static inline int perf_env__get_cpu(struct perf_env *env, struct cpu_map *map, int idx) 186868d702f7SJiri Olsa { 186968d702f7SJiri Olsa int cpu; 187068d702f7SJiri Olsa 187168d702f7SJiri Olsa if (idx > map->nr) 187268d702f7SJiri Olsa return -1; 187368d702f7SJiri Olsa 187468d702f7SJiri Olsa cpu = map->map[idx]; 187568d702f7SJiri Olsa 1876da8a58b5SJan Stancek if (cpu >= env->nr_cpus_avail) 187768d702f7SJiri Olsa return -1; 187868d702f7SJiri Olsa 187968d702f7SJiri Olsa return cpu; 188068d702f7SJiri Olsa } 188168d702f7SJiri Olsa 188268d702f7SJiri Olsa static int perf_env__get_socket(struct cpu_map *map, int idx, void *data) 188368d702f7SJiri Olsa { 188468d702f7SJiri Olsa struct perf_env *env = data; 188568d702f7SJiri Olsa int cpu = perf_env__get_cpu(env, map, idx); 188668d702f7SJiri Olsa 188768d702f7SJiri Olsa return cpu == -1 ? -1 : env->cpu[cpu].socket_id; 188868d702f7SJiri Olsa } 188968d702f7SJiri Olsa 189068d702f7SJiri Olsa static int perf_env__get_core(struct cpu_map *map, int idx, void *data) 189168d702f7SJiri Olsa { 189268d702f7SJiri Olsa struct perf_env *env = data; 189368d702f7SJiri Olsa int core = -1, cpu = perf_env__get_cpu(env, map, idx); 189468d702f7SJiri Olsa 189568d702f7SJiri Olsa if (cpu != -1) { 189668d702f7SJiri Olsa int socket_id = env->cpu[cpu].socket_id; 189768d702f7SJiri Olsa 189868d702f7SJiri Olsa /* 189968d702f7SJiri Olsa * Encode socket in upper 16 bits 190068d702f7SJiri Olsa * core_id is relative to socket, and 190168d702f7SJiri Olsa * we need a global id. So we combine 190268d702f7SJiri Olsa * socket + core id. 190368d702f7SJiri Olsa */ 190468d702f7SJiri Olsa core = (socket_id << 16) | (env->cpu[cpu].core_id & 0xffff); 190568d702f7SJiri Olsa } 190668d702f7SJiri Olsa 190768d702f7SJiri Olsa return core; 190868d702f7SJiri Olsa } 190968d702f7SJiri Olsa 191068d702f7SJiri Olsa static int perf_env__build_socket_map(struct perf_env *env, struct cpu_map *cpus, 191168d702f7SJiri Olsa struct cpu_map **sockp) 191268d702f7SJiri Olsa { 191368d702f7SJiri Olsa return cpu_map__build_map(cpus, sockp, perf_env__get_socket, env); 191468d702f7SJiri Olsa } 191568d702f7SJiri Olsa 191668d702f7SJiri Olsa static int perf_env__build_core_map(struct perf_env *env, struct cpu_map *cpus, 191768d702f7SJiri Olsa struct cpu_map **corep) 191868d702f7SJiri Olsa { 191968d702f7SJiri Olsa return cpu_map__build_map(cpus, corep, perf_env__get_core, env); 192068d702f7SJiri Olsa } 192168d702f7SJiri Olsa 192268d702f7SJiri Olsa static int perf_stat__get_socket_file(struct cpu_map *map, int idx) 192368d702f7SJiri Olsa { 192468d702f7SJiri Olsa return perf_env__get_socket(map, idx, &perf_stat.session->header.env); 192568d702f7SJiri Olsa } 192668d702f7SJiri Olsa 192768d702f7SJiri Olsa static int perf_stat__get_core_file(struct cpu_map *map, int idx) 192868d702f7SJiri Olsa { 192968d702f7SJiri Olsa return perf_env__get_core(map, idx, &perf_stat.session->header.env); 193068d702f7SJiri Olsa } 193168d702f7SJiri Olsa 193268d702f7SJiri Olsa static int perf_stat_init_aggr_mode_file(struct perf_stat *st) 193368d702f7SJiri Olsa { 193468d702f7SJiri Olsa struct perf_env *env = &st->session->header.env; 193568d702f7SJiri Olsa 193668d702f7SJiri Olsa switch (stat_config.aggr_mode) { 193768d702f7SJiri Olsa case AGGR_SOCKET: 193868d702f7SJiri Olsa if (perf_env__build_socket_map(env, evsel_list->cpus, &aggr_map)) { 193968d702f7SJiri Olsa perror("cannot build socket map"); 194068d702f7SJiri Olsa return -1; 194168d702f7SJiri Olsa } 194268d702f7SJiri Olsa aggr_get_id = perf_stat__get_socket_file; 194368d702f7SJiri Olsa break; 194468d702f7SJiri Olsa case AGGR_CORE: 194568d702f7SJiri Olsa if (perf_env__build_core_map(env, evsel_list->cpus, &aggr_map)) { 194668d702f7SJiri Olsa perror("cannot build core map"); 194768d702f7SJiri Olsa return -1; 194868d702f7SJiri Olsa } 194968d702f7SJiri Olsa aggr_get_id = perf_stat__get_core_file; 195068d702f7SJiri Olsa break; 195168d702f7SJiri Olsa case AGGR_NONE: 195268d702f7SJiri Olsa case AGGR_GLOBAL: 195368d702f7SJiri Olsa case AGGR_THREAD: 195468d702f7SJiri Olsa case AGGR_UNSET: 195568d702f7SJiri Olsa default: 195668d702f7SJiri Olsa break; 195768d702f7SJiri Olsa } 195868d702f7SJiri Olsa 195968d702f7SJiri Olsa return 0; 196068d702f7SJiri Olsa } 196168d702f7SJiri Olsa 196244b1e60aSAndi Kleen static int topdown_filter_events(const char **attr, char **str, bool use_group) 196344b1e60aSAndi Kleen { 196444b1e60aSAndi Kleen int off = 0; 196544b1e60aSAndi Kleen int i; 196644b1e60aSAndi Kleen int len = 0; 196744b1e60aSAndi Kleen char *s; 196844b1e60aSAndi Kleen 196944b1e60aSAndi Kleen for (i = 0; attr[i]; i++) { 197044b1e60aSAndi Kleen if (pmu_have_event("cpu", attr[i])) { 197144b1e60aSAndi Kleen len += strlen(attr[i]) + 1; 197244b1e60aSAndi Kleen attr[i - off] = attr[i]; 197344b1e60aSAndi Kleen } else 197444b1e60aSAndi Kleen off++; 197544b1e60aSAndi Kleen } 197644b1e60aSAndi Kleen attr[i - off] = NULL; 197744b1e60aSAndi Kleen 197844b1e60aSAndi Kleen *str = malloc(len + 1 + 2); 197944b1e60aSAndi Kleen if (!*str) 198044b1e60aSAndi Kleen return -1; 198144b1e60aSAndi Kleen s = *str; 198244b1e60aSAndi Kleen if (i - off == 0) { 198344b1e60aSAndi Kleen *s = 0; 198444b1e60aSAndi Kleen return 0; 198544b1e60aSAndi Kleen } 198644b1e60aSAndi Kleen if (use_group) 198744b1e60aSAndi Kleen *s++ = '{'; 198844b1e60aSAndi Kleen for (i = 0; attr[i]; i++) { 198944b1e60aSAndi Kleen strcpy(s, attr[i]); 199044b1e60aSAndi Kleen s += strlen(s); 199144b1e60aSAndi Kleen *s++ = ','; 199244b1e60aSAndi Kleen } 199344b1e60aSAndi Kleen if (use_group) { 199444b1e60aSAndi Kleen s[-1] = '}'; 199544b1e60aSAndi Kleen *s = 0; 199644b1e60aSAndi Kleen } else 199744b1e60aSAndi Kleen s[-1] = 0; 199844b1e60aSAndi Kleen return 0; 199944b1e60aSAndi Kleen } 200044b1e60aSAndi Kleen 200144b1e60aSAndi Kleen __weak bool arch_topdown_check_group(bool *warn) 200244b1e60aSAndi Kleen { 200344b1e60aSAndi Kleen *warn = false; 200444b1e60aSAndi Kleen return false; 200544b1e60aSAndi Kleen } 200644b1e60aSAndi Kleen 200744b1e60aSAndi Kleen __weak void arch_topdown_group_warn(void) 200844b1e60aSAndi Kleen { 200944b1e60aSAndi Kleen } 201044b1e60aSAndi Kleen 20112cba3ffbSIngo Molnar /* 20122cba3ffbSIngo Molnar * Add default attributes, if there were no attributes specified or 20132cba3ffbSIngo Molnar * if -d/--detailed, -d -d or -d -d -d is used: 20142cba3ffbSIngo Molnar */ 20152cba3ffbSIngo Molnar static int add_default_attributes(void) 20162cba3ffbSIngo Molnar { 201744b1e60aSAndi Kleen int err; 20189dec4473SAndi Kleen struct perf_event_attr default_attrs0[] = { 2019b070a547SArnaldo Carvalho de Melo 2020b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK }, 2021b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES }, 2022b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS }, 2023b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS }, 2024b070a547SArnaldo Carvalho de Melo 2025b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES }, 20269dec4473SAndi Kleen }; 20279dec4473SAndi Kleen struct perf_event_attr frontend_attrs[] = { 2028b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND }, 20299dec4473SAndi Kleen }; 20309dec4473SAndi Kleen struct perf_event_attr backend_attrs[] = { 2031b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND }, 20329dec4473SAndi Kleen }; 20339dec4473SAndi Kleen struct perf_event_attr default_attrs1[] = { 2034b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS }, 2035b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS }, 2036b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES }, 2037b070a547SArnaldo Carvalho de Melo 2038b070a547SArnaldo Carvalho de Melo }; 2039b070a547SArnaldo Carvalho de Melo 2040b070a547SArnaldo Carvalho de Melo /* 2041b070a547SArnaldo Carvalho de Melo * Detailed stats (-d), covering the L1 and last level data caches: 2042b070a547SArnaldo Carvalho de Melo */ 2043b070a547SArnaldo Carvalho de Melo struct perf_event_attr detailed_attrs[] = { 2044b070a547SArnaldo Carvalho de Melo 2045b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2046b070a547SArnaldo Carvalho de Melo .config = 2047b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 2048b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2049b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2050b070a547SArnaldo Carvalho de Melo 2051b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2052b070a547SArnaldo Carvalho de Melo .config = 2053b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 2054b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2055b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2056b070a547SArnaldo Carvalho de Melo 2057b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2058b070a547SArnaldo Carvalho de Melo .config = 2059b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 2060b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2061b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2062b070a547SArnaldo Carvalho de Melo 2063b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2064b070a547SArnaldo Carvalho de Melo .config = 2065b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 2066b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2067b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2068b070a547SArnaldo Carvalho de Melo }; 2069b070a547SArnaldo Carvalho de Melo 2070b070a547SArnaldo Carvalho de Melo /* 2071b070a547SArnaldo Carvalho de Melo * Very detailed stats (-d -d), covering the instruction cache and the TLB caches: 2072b070a547SArnaldo Carvalho de Melo */ 2073b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_detailed_attrs[] = { 2074b070a547SArnaldo Carvalho de Melo 2075b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2076b070a547SArnaldo Carvalho de Melo .config = 2077b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 2078b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2079b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2080b070a547SArnaldo Carvalho de Melo 2081b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2082b070a547SArnaldo Carvalho de Melo .config = 2083b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 2084b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2085b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2086b070a547SArnaldo Carvalho de Melo 2087b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2088b070a547SArnaldo Carvalho de Melo .config = 2089b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 2090b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2091b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2092b070a547SArnaldo Carvalho de Melo 2093b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2094b070a547SArnaldo Carvalho de Melo .config = 2095b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 2096b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2097b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2098b070a547SArnaldo Carvalho de Melo 2099b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2100b070a547SArnaldo Carvalho de Melo .config = 2101b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 2102b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2103b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2104b070a547SArnaldo Carvalho de Melo 2105b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2106b070a547SArnaldo Carvalho de Melo .config = 2107b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 2108b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 2109b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2110b070a547SArnaldo Carvalho de Melo 2111b070a547SArnaldo Carvalho de Melo }; 2112b070a547SArnaldo Carvalho de Melo 2113b070a547SArnaldo Carvalho de Melo /* 2114b070a547SArnaldo Carvalho de Melo * Very, very detailed stats (-d -d -d), adding prefetch events: 2115b070a547SArnaldo Carvalho de Melo */ 2116b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_very_detailed_attrs[] = { 2117b070a547SArnaldo Carvalho de Melo 2118b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2119b070a547SArnaldo Carvalho de Melo .config = 2120b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 2121b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 2122b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 2123b070a547SArnaldo Carvalho de Melo 2124b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 2125b070a547SArnaldo Carvalho de Melo .config = 2126b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 2127b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 2128b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 2129b070a547SArnaldo Carvalho de Melo }; 2130b070a547SArnaldo Carvalho de Melo 21312cba3ffbSIngo Molnar /* Set attrs if no event is selected and !null_run: */ 21322cba3ffbSIngo Molnar if (null_run) 21332cba3ffbSIngo Molnar return 0; 21342cba3ffbSIngo Molnar 21354cabc3d1SAndi Kleen if (transaction_run) { 21364cabc3d1SAndi Kleen if (pmu_have_event("cpu", "cycles-ct") && 21374cabc3d1SAndi Kleen pmu_have_event("cpu", "el-start")) 2138a454742cSJiri Olsa err = parse_events(evsel_list, transaction_attrs, NULL); 21394cabc3d1SAndi Kleen else 2140a454742cSJiri Olsa err = parse_events(evsel_list, transaction_limited_attrs, NULL); 2141a454742cSJiri Olsa if (err) { 21424cabc3d1SAndi Kleen fprintf(stderr, "Cannot set up transaction events\n"); 21434cabc3d1SAndi Kleen return -1; 21444cabc3d1SAndi Kleen } 21454cabc3d1SAndi Kleen return 0; 21464cabc3d1SAndi Kleen } 21474cabc3d1SAndi Kleen 214844b1e60aSAndi Kleen if (topdown_run) { 214944b1e60aSAndi Kleen char *str = NULL; 215044b1e60aSAndi Kleen bool warn = false; 215144b1e60aSAndi Kleen 215244b1e60aSAndi Kleen if (stat_config.aggr_mode != AGGR_GLOBAL && 215344b1e60aSAndi Kleen stat_config.aggr_mode != AGGR_CORE) { 215444b1e60aSAndi Kleen pr_err("top down event configuration requires --per-core mode\n"); 215544b1e60aSAndi Kleen return -1; 215644b1e60aSAndi Kleen } 215744b1e60aSAndi Kleen stat_config.aggr_mode = AGGR_CORE; 215844b1e60aSAndi Kleen if (nr_cgroups || !target__has_cpu(&target)) { 215944b1e60aSAndi Kleen pr_err("top down event configuration requires system-wide mode (-a)\n"); 216044b1e60aSAndi Kleen return -1; 216144b1e60aSAndi Kleen } 216244b1e60aSAndi Kleen 216344b1e60aSAndi Kleen if (!force_metric_only) 216444b1e60aSAndi Kleen metric_only = true; 216544b1e60aSAndi Kleen if (topdown_filter_events(topdown_attrs, &str, 216644b1e60aSAndi Kleen arch_topdown_check_group(&warn)) < 0) { 216744b1e60aSAndi Kleen pr_err("Out of memory\n"); 216844b1e60aSAndi Kleen return -1; 216944b1e60aSAndi Kleen } 217044b1e60aSAndi Kleen if (topdown_attrs[0] && str) { 217144b1e60aSAndi Kleen if (warn) 217244b1e60aSAndi Kleen arch_topdown_group_warn(); 217344b1e60aSAndi Kleen err = parse_events(evsel_list, str, NULL); 217444b1e60aSAndi Kleen if (err) { 217544b1e60aSAndi Kleen fprintf(stderr, 217644b1e60aSAndi Kleen "Cannot set up top down events %s: %d\n", 217744b1e60aSAndi Kleen str, err); 217844b1e60aSAndi Kleen free(str); 217944b1e60aSAndi Kleen return -1; 218044b1e60aSAndi Kleen } 218144b1e60aSAndi Kleen } else { 218244b1e60aSAndi Kleen fprintf(stderr, "System does not support topdown\n"); 218344b1e60aSAndi Kleen return -1; 218444b1e60aSAndi Kleen } 218544b1e60aSAndi Kleen free(str); 218644b1e60aSAndi Kleen } 218744b1e60aSAndi Kleen 21882cba3ffbSIngo Molnar if (!evsel_list->nr_entries) { 2189a1f3d567SNamhyung Kim if (target__has_cpu(&target)) 2190a1f3d567SNamhyung Kim default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK; 2191a1f3d567SNamhyung Kim 21929dec4473SAndi Kleen if (perf_evlist__add_default_attrs(evsel_list, default_attrs0) < 0) 21939dec4473SAndi Kleen return -1; 21949dec4473SAndi Kleen if (pmu_have_event("cpu", "stalled-cycles-frontend")) { 21959dec4473SAndi Kleen if (perf_evlist__add_default_attrs(evsel_list, 21969dec4473SAndi Kleen frontend_attrs) < 0) 21979dec4473SAndi Kleen return -1; 21989dec4473SAndi Kleen } 21999dec4473SAndi Kleen if (pmu_have_event("cpu", "stalled-cycles-backend")) { 22009dec4473SAndi Kleen if (perf_evlist__add_default_attrs(evsel_list, 22019dec4473SAndi Kleen backend_attrs) < 0) 22029dec4473SAndi Kleen return -1; 22039dec4473SAndi Kleen } 22049dec4473SAndi Kleen if (perf_evlist__add_default_attrs(evsel_list, default_attrs1) < 0) 22052cba3ffbSIngo Molnar return -1; 22062cba3ffbSIngo Molnar } 22072cba3ffbSIngo Molnar 22082cba3ffbSIngo Molnar /* Detailed events get appended to the event list: */ 22092cba3ffbSIngo Molnar 22102cba3ffbSIngo Molnar if (detailed_run < 1) 22112cba3ffbSIngo Molnar return 0; 22122cba3ffbSIngo Molnar 22132cba3ffbSIngo Molnar /* Append detailed run extra attributes: */ 221479695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0) 22152cba3ffbSIngo Molnar return -1; 22162cba3ffbSIngo Molnar 22172cba3ffbSIngo Molnar if (detailed_run < 2) 22182cba3ffbSIngo Molnar return 0; 22192cba3ffbSIngo Molnar 22202cba3ffbSIngo Molnar /* Append very detailed run extra attributes: */ 222179695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0) 22222cba3ffbSIngo Molnar return -1; 22232cba3ffbSIngo Molnar 22242cba3ffbSIngo Molnar if (detailed_run < 3) 22252cba3ffbSIngo Molnar return 0; 22262cba3ffbSIngo Molnar 22272cba3ffbSIngo Molnar /* Append very, very detailed run extra attributes: */ 222879695e1bSArnaldo Carvalho de Melo return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs); 22292cba3ffbSIngo Molnar } 22302cba3ffbSIngo Molnar 22318a59f3ccSJiri Olsa static const char * const stat_record_usage[] = { 22324979d0c7SJiri Olsa "perf stat record [<options>]", 22334979d0c7SJiri Olsa NULL, 22344979d0c7SJiri Olsa }; 22354979d0c7SJiri Olsa 22363ba78bd0SJiri Olsa static void init_features(struct perf_session *session) 22373ba78bd0SJiri Olsa { 22383ba78bd0SJiri Olsa int feat; 22393ba78bd0SJiri Olsa 22403ba78bd0SJiri Olsa for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++) 22413ba78bd0SJiri Olsa perf_header__set_feat(&session->header, feat); 22423ba78bd0SJiri Olsa 22433ba78bd0SJiri Olsa perf_header__clear_feat(&session->header, HEADER_BUILD_ID); 22443ba78bd0SJiri Olsa perf_header__clear_feat(&session->header, HEADER_TRACING_DATA); 22453ba78bd0SJiri Olsa perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK); 22463ba78bd0SJiri Olsa perf_header__clear_feat(&session->header, HEADER_AUXTRACE); 22473ba78bd0SJiri Olsa } 22483ba78bd0SJiri Olsa 22494979d0c7SJiri Olsa static int __cmd_record(int argc, const char **argv) 22504979d0c7SJiri Olsa { 22514979d0c7SJiri Olsa struct perf_session *session; 22524979d0c7SJiri Olsa struct perf_data_file *file = &perf_stat.file; 22534979d0c7SJiri Olsa 22548a59f3ccSJiri Olsa argc = parse_options(argc, argv, stat_options, stat_record_usage, 22554979d0c7SJiri Olsa PARSE_OPT_STOP_AT_NON_OPTION); 22564979d0c7SJiri Olsa 22574979d0c7SJiri Olsa if (output_name) 22584979d0c7SJiri Olsa file->path = output_name; 22594979d0c7SJiri Olsa 2260e9d6db8eSJiri Olsa if (run_count != 1 || forever) { 2261e9d6db8eSJiri Olsa pr_err("Cannot use -r option with perf stat record.\n"); 2262e9d6db8eSJiri Olsa return -1; 2263e9d6db8eSJiri Olsa } 2264e9d6db8eSJiri Olsa 22654979d0c7SJiri Olsa session = perf_session__new(file, false, NULL); 22664979d0c7SJiri Olsa if (session == NULL) { 22674979d0c7SJiri Olsa pr_err("Perf session creation failed.\n"); 22684979d0c7SJiri Olsa return -1; 22694979d0c7SJiri Olsa } 22704979d0c7SJiri Olsa 22713ba78bd0SJiri Olsa init_features(session); 22723ba78bd0SJiri Olsa 22734979d0c7SJiri Olsa session->evlist = evsel_list; 22744979d0c7SJiri Olsa perf_stat.session = session; 22754979d0c7SJiri Olsa perf_stat.record = true; 22764979d0c7SJiri Olsa return argc; 22774979d0c7SJiri Olsa } 22784979d0c7SJiri Olsa 2279a56f9390SJiri Olsa static int process_stat_round_event(struct perf_tool *tool __maybe_unused, 2280a56f9390SJiri Olsa union perf_event *event, 2281a56f9390SJiri Olsa struct perf_session *session) 2282a56f9390SJiri Olsa { 2283e3b03b6cSAndi Kleen struct stat_round_event *stat_round = &event->stat_round; 2284a56f9390SJiri Olsa struct perf_evsel *counter; 2285a56f9390SJiri Olsa struct timespec tsh, *ts = NULL; 2286a56f9390SJiri Olsa const char **argv = session->header.env.cmdline_argv; 2287a56f9390SJiri Olsa int argc = session->header.env.nr_cmdline; 2288a56f9390SJiri Olsa 2289e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evsel_list, counter) 2290a56f9390SJiri Olsa perf_stat_process_counter(&stat_config, counter); 2291a56f9390SJiri Olsa 2292e3b03b6cSAndi Kleen if (stat_round->type == PERF_STAT_ROUND_TYPE__FINAL) 2293e3b03b6cSAndi Kleen update_stats(&walltime_nsecs_stats, stat_round->time); 2294a56f9390SJiri Olsa 2295e3b03b6cSAndi Kleen if (stat_config.interval && stat_round->time) { 2296bd48c63eSArnaldo Carvalho de Melo tsh.tv_sec = stat_round->time / NSEC_PER_SEC; 2297bd48c63eSArnaldo Carvalho de Melo tsh.tv_nsec = stat_round->time % NSEC_PER_SEC; 2298a56f9390SJiri Olsa ts = &tsh; 2299a56f9390SJiri Olsa } 2300a56f9390SJiri Olsa 2301a56f9390SJiri Olsa print_counters(ts, argc, argv); 2302a56f9390SJiri Olsa return 0; 2303a56f9390SJiri Olsa } 2304a56f9390SJiri Olsa 230562ba18baSJiri Olsa static 23067e6a7998SArnaldo Carvalho de Melo int process_stat_config_event(struct perf_tool *tool, 230762ba18baSJiri Olsa union perf_event *event, 230862ba18baSJiri Olsa struct perf_session *session __maybe_unused) 230962ba18baSJiri Olsa { 231068d702f7SJiri Olsa struct perf_stat *st = container_of(tool, struct perf_stat, tool); 231168d702f7SJiri Olsa 231262ba18baSJiri Olsa perf_event__read_stat_config(&stat_config, &event->stat_config); 231368d702f7SJiri Olsa 231489af4e05SJiri Olsa if (cpu_map__empty(st->cpus)) { 231589af4e05SJiri Olsa if (st->aggr_mode != AGGR_UNSET) 231689af4e05SJiri Olsa pr_warning("warning: processing task data, aggregation mode not set\n"); 231789af4e05SJiri Olsa return 0; 231889af4e05SJiri Olsa } 231989af4e05SJiri Olsa 232089af4e05SJiri Olsa if (st->aggr_mode != AGGR_UNSET) 232189af4e05SJiri Olsa stat_config.aggr_mode = st->aggr_mode; 232289af4e05SJiri Olsa 232368d702f7SJiri Olsa if (perf_stat.file.is_pipe) 232468d702f7SJiri Olsa perf_stat_init_aggr_mode(); 232568d702f7SJiri Olsa else 232668d702f7SJiri Olsa perf_stat_init_aggr_mode_file(st); 232768d702f7SJiri Olsa 232862ba18baSJiri Olsa return 0; 232962ba18baSJiri Olsa } 233062ba18baSJiri Olsa 23311975d36eSJiri Olsa static int set_maps(struct perf_stat *st) 23321975d36eSJiri Olsa { 23331975d36eSJiri Olsa if (!st->cpus || !st->threads) 23341975d36eSJiri Olsa return 0; 23351975d36eSJiri Olsa 23361975d36eSJiri Olsa if (WARN_ONCE(st->maps_allocated, "stats double allocation\n")) 23371975d36eSJiri Olsa return -EINVAL; 23381975d36eSJiri Olsa 23391975d36eSJiri Olsa perf_evlist__set_maps(evsel_list, st->cpus, st->threads); 23401975d36eSJiri Olsa 23411975d36eSJiri Olsa if (perf_evlist__alloc_stats(evsel_list, true)) 23421975d36eSJiri Olsa return -ENOMEM; 23431975d36eSJiri Olsa 23441975d36eSJiri Olsa st->maps_allocated = true; 23451975d36eSJiri Olsa return 0; 23461975d36eSJiri Olsa } 23471975d36eSJiri Olsa 23481975d36eSJiri Olsa static 23497e6a7998SArnaldo Carvalho de Melo int process_thread_map_event(struct perf_tool *tool, 23501975d36eSJiri Olsa union perf_event *event, 23511975d36eSJiri Olsa struct perf_session *session __maybe_unused) 23521975d36eSJiri Olsa { 23531975d36eSJiri Olsa struct perf_stat *st = container_of(tool, struct perf_stat, tool); 23541975d36eSJiri Olsa 23551975d36eSJiri Olsa if (st->threads) { 23561975d36eSJiri Olsa pr_warning("Extra thread map event, ignoring.\n"); 23571975d36eSJiri Olsa return 0; 23581975d36eSJiri Olsa } 23591975d36eSJiri Olsa 23601975d36eSJiri Olsa st->threads = thread_map__new_event(&event->thread_map); 23611975d36eSJiri Olsa if (!st->threads) 23621975d36eSJiri Olsa return -ENOMEM; 23631975d36eSJiri Olsa 23641975d36eSJiri Olsa return set_maps(st); 23651975d36eSJiri Olsa } 23661975d36eSJiri Olsa 23671975d36eSJiri Olsa static 23687e6a7998SArnaldo Carvalho de Melo int process_cpu_map_event(struct perf_tool *tool, 23691975d36eSJiri Olsa union perf_event *event, 23701975d36eSJiri Olsa struct perf_session *session __maybe_unused) 23711975d36eSJiri Olsa { 23721975d36eSJiri Olsa struct perf_stat *st = container_of(tool, struct perf_stat, tool); 23731975d36eSJiri Olsa struct cpu_map *cpus; 23741975d36eSJiri Olsa 23751975d36eSJiri Olsa if (st->cpus) { 23761975d36eSJiri Olsa pr_warning("Extra cpu map event, ignoring.\n"); 23771975d36eSJiri Olsa return 0; 23781975d36eSJiri Olsa } 23791975d36eSJiri Olsa 23801975d36eSJiri Olsa cpus = cpu_map__new_data(&event->cpu_map.data); 23811975d36eSJiri Olsa if (!cpus) 23821975d36eSJiri Olsa return -ENOMEM; 23831975d36eSJiri Olsa 23841975d36eSJiri Olsa st->cpus = cpus; 23851975d36eSJiri Olsa return set_maps(st); 23861975d36eSJiri Olsa } 23871975d36eSJiri Olsa 23888a59f3ccSJiri Olsa static const char * const stat_report_usage[] = { 2389ba6039b6SJiri Olsa "perf stat report [<options>]", 2390ba6039b6SJiri Olsa NULL, 2391ba6039b6SJiri Olsa }; 2392ba6039b6SJiri Olsa 2393ba6039b6SJiri Olsa static struct perf_stat perf_stat = { 2394ba6039b6SJiri Olsa .tool = { 2395ba6039b6SJiri Olsa .attr = perf_event__process_attr, 2396fa6ea781SJiri Olsa .event_update = perf_event__process_event_update, 23971975d36eSJiri Olsa .thread_map = process_thread_map_event, 23981975d36eSJiri Olsa .cpu_map = process_cpu_map_event, 239962ba18baSJiri Olsa .stat_config = process_stat_config_event, 2400a56f9390SJiri Olsa .stat = perf_event__process_stat_event, 2401a56f9390SJiri Olsa .stat_round = process_stat_round_event, 2402ba6039b6SJiri Olsa }, 240389af4e05SJiri Olsa .aggr_mode = AGGR_UNSET, 2404ba6039b6SJiri Olsa }; 2405ba6039b6SJiri Olsa 2406ba6039b6SJiri Olsa static int __cmd_report(int argc, const char **argv) 2407ba6039b6SJiri Olsa { 2408ba6039b6SJiri Olsa struct perf_session *session; 2409ba6039b6SJiri Olsa const struct option options[] = { 2410ba6039b6SJiri Olsa OPT_STRING('i', "input", &input_name, "file", "input file name"), 241189af4e05SJiri Olsa OPT_SET_UINT(0, "per-socket", &perf_stat.aggr_mode, 241289af4e05SJiri Olsa "aggregate counts per processor socket", AGGR_SOCKET), 241389af4e05SJiri Olsa OPT_SET_UINT(0, "per-core", &perf_stat.aggr_mode, 241489af4e05SJiri Olsa "aggregate counts per physical processor core", AGGR_CORE), 241589af4e05SJiri Olsa OPT_SET_UINT('A', "no-aggr", &perf_stat.aggr_mode, 241689af4e05SJiri Olsa "disable CPU count aggregation", AGGR_NONE), 2417ba6039b6SJiri Olsa OPT_END() 2418ba6039b6SJiri Olsa }; 2419ba6039b6SJiri Olsa struct stat st; 2420ba6039b6SJiri Olsa int ret; 2421ba6039b6SJiri Olsa 24228a59f3ccSJiri Olsa argc = parse_options(argc, argv, options, stat_report_usage, 0); 2423ba6039b6SJiri Olsa 2424ba6039b6SJiri Olsa if (!input_name || !strlen(input_name)) { 2425ba6039b6SJiri Olsa if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode)) 2426ba6039b6SJiri Olsa input_name = "-"; 2427ba6039b6SJiri Olsa else 2428ba6039b6SJiri Olsa input_name = "perf.data"; 2429ba6039b6SJiri Olsa } 2430ba6039b6SJiri Olsa 2431ba6039b6SJiri Olsa perf_stat.file.path = input_name; 2432ba6039b6SJiri Olsa perf_stat.file.mode = PERF_DATA_MODE_READ; 2433ba6039b6SJiri Olsa 2434ba6039b6SJiri Olsa session = perf_session__new(&perf_stat.file, false, &perf_stat.tool); 2435ba6039b6SJiri Olsa if (session == NULL) 2436ba6039b6SJiri Olsa return -1; 2437ba6039b6SJiri Olsa 2438ba6039b6SJiri Olsa perf_stat.session = session; 2439ba6039b6SJiri Olsa stat_config.output = stderr; 2440ba6039b6SJiri Olsa evsel_list = session->evlist; 2441ba6039b6SJiri Olsa 2442ba6039b6SJiri Olsa ret = perf_session__process_events(session); 2443ba6039b6SJiri Olsa if (ret) 2444ba6039b6SJiri Olsa return ret; 2445ba6039b6SJiri Olsa 2446ba6039b6SJiri Olsa perf_session__delete(session); 2447ba6039b6SJiri Olsa return 0; 2448ba6039b6SJiri Olsa } 2449ba6039b6SJiri Olsa 2450e3ba76deSJiri Olsa static void setup_system_wide(int forks) 2451e3ba76deSJiri Olsa { 2452e3ba76deSJiri Olsa /* 2453e3ba76deSJiri Olsa * Make system wide (-a) the default target if 2454e3ba76deSJiri Olsa * no target was specified and one of following 2455e3ba76deSJiri Olsa * conditions is met: 2456e3ba76deSJiri Olsa * 2457e3ba76deSJiri Olsa * - there's no workload specified 2458e3ba76deSJiri Olsa * - there is workload specified but all requested 2459e3ba76deSJiri Olsa * events are system wide events 2460e3ba76deSJiri Olsa */ 2461e3ba76deSJiri Olsa if (!target__none(&target)) 2462e3ba76deSJiri Olsa return; 2463e3ba76deSJiri Olsa 2464e3ba76deSJiri Olsa if (!forks) 2465e3ba76deSJiri Olsa target.system_wide = true; 2466e3ba76deSJiri Olsa else { 2467e3ba76deSJiri Olsa struct perf_evsel *counter; 2468e3ba76deSJiri Olsa 2469e3ba76deSJiri Olsa evlist__for_each_entry(evsel_list, counter) { 2470e3ba76deSJiri Olsa if (!counter->system_wide) 2471e3ba76deSJiri Olsa return; 2472e3ba76deSJiri Olsa } 2473e3ba76deSJiri Olsa 2474e3ba76deSJiri Olsa if (evsel_list->nr_entries) 2475e3ba76deSJiri Olsa target.system_wide = true; 2476e3ba76deSJiri Olsa } 2477e3ba76deSJiri Olsa } 2478e3ba76deSJiri Olsa 24791d037ca1SIrina Tirdea int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused) 248086470930SIngo Molnar { 2481b070a547SArnaldo Carvalho de Melo const char * const stat_usage[] = { 2482b070a547SArnaldo Carvalho de Melo "perf stat [<options>] [<command>]", 2483b070a547SArnaldo Carvalho de Melo NULL 2484b070a547SArnaldo Carvalho de Melo }; 2485cc03c542SNamhyung Kim int status = -EINVAL, run_idx; 24864aa9015fSStephane Eranian const char *mode; 24875821522eSJiri Olsa FILE *output = stderr; 2488ec0d3d1fSJiri Olsa unsigned int interval; 2489ba6039b6SJiri Olsa const char * const stat_subcommands[] = { "record", "report" }; 249042202dd5SIngo Molnar 24915af52b51SStephane Eranian setlocale(LC_ALL, ""); 24925af52b51SStephane Eranian 2493334fe7a3SNamhyung Kim evsel_list = perf_evlist__new(); 2494361c99a6SArnaldo Carvalho de Melo if (evsel_list == NULL) 2495361c99a6SArnaldo Carvalho de Melo return -ENOMEM; 2496361c99a6SArnaldo Carvalho de Melo 24971669e509SWang Nan parse_events__shrink_config_terms(); 24984979d0c7SJiri Olsa argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands, 24994979d0c7SJiri Olsa (const char **) stat_usage, 2500a0541234SAnton Blanchard PARSE_OPT_STOP_AT_NON_OPTION); 2501fb4605baSAndi Kleen perf_stat__init_shadow_stats(); 2502d7470b6aSStephane Eranian 25036edb78a2SJiri Olsa if (csv_sep) { 25046edb78a2SJiri Olsa csv_output = true; 25056edb78a2SJiri Olsa if (!strcmp(csv_sep, "\\t")) 25066edb78a2SJiri Olsa csv_sep = "\t"; 25076edb78a2SJiri Olsa } else 25086edb78a2SJiri Olsa csv_sep = DEFAULT_SEPARATOR; 25096edb78a2SJiri Olsa 25104979d0c7SJiri Olsa if (argc && !strncmp(argv[0], "rec", 3)) { 25114979d0c7SJiri Olsa argc = __cmd_record(argc, argv); 25124979d0c7SJiri Olsa if (argc < 0) 25134979d0c7SJiri Olsa return -1; 2514ba6039b6SJiri Olsa } else if (argc && !strncmp(argv[0], "rep", 3)) 2515ba6039b6SJiri Olsa return __cmd_report(argc, argv); 25164979d0c7SJiri Olsa 2517ec0d3d1fSJiri Olsa interval = stat_config.interval; 2518ec0d3d1fSJiri Olsa 25194979d0c7SJiri Olsa /* 25204979d0c7SJiri Olsa * For record command the -o is already taken care of. 25214979d0c7SJiri Olsa */ 25224979d0c7SJiri Olsa if (!STAT_RECORD && output_name && strcmp(output_name, "-")) 25234aa9015fSStephane Eranian output = NULL; 25244aa9015fSStephane Eranian 252556f3bae7SJim Cromie if (output_name && output_fd) { 252656f3bae7SJim Cromie fprintf(stderr, "cannot use both --output and --log-fd\n"); 2527e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "o", 1); 2528e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "log-fd", 0); 2529cc03c542SNamhyung Kim goto out; 253056f3bae7SJim Cromie } 2531fc3e4d07SStephane Eranian 253254b50916SAndi Kleen if (metric_only && stat_config.aggr_mode == AGGR_THREAD) { 253354b50916SAndi Kleen fprintf(stderr, "--metric-only is not supported with --per-thread\n"); 253454b50916SAndi Kleen goto out; 253554b50916SAndi Kleen } 253654b50916SAndi Kleen 253754b50916SAndi Kleen if (metric_only && run_count > 1) { 253854b50916SAndi Kleen fprintf(stderr, "--metric-only is not supported with -r\n"); 253954b50916SAndi Kleen goto out; 254054b50916SAndi Kleen } 254154b50916SAndi Kleen 2542fc3e4d07SStephane Eranian if (output_fd < 0) { 2543fc3e4d07SStephane Eranian fprintf(stderr, "argument to --log-fd must be a > 0\n"); 2544e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "log-fd", 0); 2545cc03c542SNamhyung Kim goto out; 2546fc3e4d07SStephane Eranian } 2547fc3e4d07SStephane Eranian 25484aa9015fSStephane Eranian if (!output) { 25494aa9015fSStephane Eranian struct timespec tm; 25504aa9015fSStephane Eranian mode = append_file ? "a" : "w"; 25514aa9015fSStephane Eranian 25524aa9015fSStephane Eranian output = fopen(output_name, mode); 25534aa9015fSStephane Eranian if (!output) { 25544aa9015fSStephane Eranian perror("failed to create output file"); 2555fceda7feSDavid Ahern return -1; 25564aa9015fSStephane Eranian } 25574aa9015fSStephane Eranian clock_gettime(CLOCK_REALTIME, &tm); 25584aa9015fSStephane Eranian fprintf(output, "# started on %s\n", ctime(&tm.tv_sec)); 2559fc3e4d07SStephane Eranian } else if (output_fd > 0) { 256056f3bae7SJim Cromie mode = append_file ? "a" : "w"; 256156f3bae7SJim Cromie output = fdopen(output_fd, mode); 256256f3bae7SJim Cromie if (!output) { 256356f3bae7SJim Cromie perror("Failed opening logfd"); 256456f3bae7SJim Cromie return -errno; 256556f3bae7SJim Cromie } 25664aa9015fSStephane Eranian } 25674aa9015fSStephane Eranian 25685821522eSJiri Olsa stat_config.output = output; 25695821522eSJiri Olsa 2570d7470b6aSStephane Eranian /* 2571d7470b6aSStephane Eranian * let the spreadsheet do the pretty-printing 2572d7470b6aSStephane Eranian */ 2573d7470b6aSStephane Eranian if (csv_output) { 257461a9f324SJim Cromie /* User explicitly passed -B? */ 2575d7470b6aSStephane Eranian if (big_num_opt == 1) { 2576d7470b6aSStephane Eranian fprintf(stderr, "-B option not supported with -x\n"); 2577e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "B", 1); 2578e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "x", 1); 2579cc03c542SNamhyung Kim goto out; 2580d7470b6aSStephane Eranian } else /* Nope, so disable big number formatting */ 2581d7470b6aSStephane Eranian big_num = false; 2582d7470b6aSStephane Eranian } else if (big_num_opt == 0) /* User passed --no-big-num */ 2583d7470b6aSStephane Eranian big_num = false; 2584d7470b6aSStephane Eranian 2585e3ba76deSJiri Olsa setup_system_wide(argc); 2586ac3063bdSDavid Ahern 2587a7e191c3SFrederik Deweerdt if (run_count < 0) { 2588cc03c542SNamhyung Kim pr_err("Run count must be a positive number\n"); 2589e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "r", 1); 2590cc03c542SNamhyung Kim goto out; 2591a7e191c3SFrederik Deweerdt } else if (run_count == 0) { 2592a7e191c3SFrederik Deweerdt forever = true; 2593a7e191c3SFrederik Deweerdt run_count = 1; 2594a7e191c3SFrederik Deweerdt } 259586470930SIngo Molnar 2596421a50f3SJiri Olsa if ((stat_config.aggr_mode == AGGR_THREAD) && !target__has_task(&target)) { 259732b8af82SJiri Olsa fprintf(stderr, "The --per-thread option is only available " 259832b8af82SJiri Olsa "when monitoring via -p -t options.\n"); 2599e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "p", 1); 2600e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "t", 1); 260132b8af82SJiri Olsa goto out; 260232b8af82SJiri Olsa } 260332b8af82SJiri Olsa 260432b8af82SJiri Olsa /* 260532b8af82SJiri Olsa * no_aggr, cgroup are for system-wide only 260632b8af82SJiri Olsa * --per-thread is aggregated per thread, we dont mix it with cpu mode 260732b8af82SJiri Olsa */ 2608421a50f3SJiri Olsa if (((stat_config.aggr_mode != AGGR_GLOBAL && 2609421a50f3SJiri Olsa stat_config.aggr_mode != AGGR_THREAD) || nr_cgroups) && 2610602ad878SArnaldo Carvalho de Melo !target__has_cpu(&target)) { 2611023695d9SStephane Eranian fprintf(stderr, "both cgroup and no-aggregation " 2612023695d9SStephane Eranian "modes only available in system-wide mode\n"); 2613023695d9SStephane Eranian 2614e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "G", 1); 2615e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "A", 1); 2616e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "a", 1); 2617cc03c542SNamhyung Kim goto out; 2618d7e7a451SStephane Eranian } 2619d7e7a451SStephane Eranian 26202cba3ffbSIngo Molnar if (add_default_attributes()) 2621c6264defSIngo Molnar goto out; 262286470930SIngo Molnar 2623602ad878SArnaldo Carvalho de Melo target__validate(&target); 26245c98d466SArnaldo Carvalho de Melo 262577a6f014SNamhyung Kim if (perf_evlist__create_maps(evsel_list, &target) < 0) { 2626602ad878SArnaldo Carvalho de Melo if (target__has_task(&target)) { 26275c98d466SArnaldo Carvalho de Melo pr_err("Problems finding threads of monitor\n"); 2628e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "p", 1); 2629e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "t", 1); 2630602ad878SArnaldo Carvalho de Melo } else if (target__has_cpu(&target)) { 263160d567e2SArnaldo Carvalho de Melo perror("failed to parse CPUs map"); 2632e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "C", 1); 2633e0547311SJiri Olsa parse_options_usage(NULL, stat_options, "a", 1); 2634cc03c542SNamhyung Kim } 2635cc03c542SNamhyung Kim goto out; 263660d567e2SArnaldo Carvalho de Melo } 263732b8af82SJiri Olsa 263832b8af82SJiri Olsa /* 263932b8af82SJiri Olsa * Initialize thread_map with comm names, 264032b8af82SJiri Olsa * so we could print it out on output. 264132b8af82SJiri Olsa */ 2642421a50f3SJiri Olsa if (stat_config.aggr_mode == AGGR_THREAD) 264332b8af82SJiri Olsa thread_map__read_comms(evsel_list->threads); 264432b8af82SJiri Olsa 264513370a9bSStephane Eranian if (interval && interval < 100) { 264619afd104SKan Liang if (interval < 10) { 264719afd104SKan Liang pr_err("print interval must be >= 10ms\n"); 2648e0547311SJiri Olsa parse_options_usage(stat_usage, stat_options, "I", 1); 264903ad9747SArnaldo Carvalho de Melo goto out; 265019afd104SKan Liang } else 265119afd104SKan Liang pr_warning("print interval < 100ms. " 265219afd104SKan Liang "The overhead percentage could be high in some cases. " 265319afd104SKan Liang "Please proceed with caution.\n"); 265413370a9bSStephane Eranian } 2655c45c6ea2SStephane Eranian 2656d134ffb9SArnaldo Carvalho de Melo if (perf_evlist__alloc_stats(evsel_list, interval)) 265703ad9747SArnaldo Carvalho de Melo goto out; 2658d6d901c2SZhang, Yanmin 265986ee6e18SStephane Eranian if (perf_stat_init_aggr_mode()) 266003ad9747SArnaldo Carvalho de Melo goto out; 266186ee6e18SStephane Eranian 266286470930SIngo Molnar /* 266386470930SIngo Molnar * We dont want to block the signals - that would cause 266486470930SIngo Molnar * child tasks to inherit that and Ctrl-C would not work. 266586470930SIngo Molnar * What we want is for Ctrl-C to work in the exec()-ed 266686470930SIngo Molnar * task, but being ignored by perf stat itself: 266786470930SIngo Molnar */ 2668f7b7c26eSPeter Zijlstra atexit(sig_atexit); 2669a7e191c3SFrederik Deweerdt if (!forever) 267086470930SIngo Molnar signal(SIGINT, skip_signal); 267113370a9bSStephane Eranian signal(SIGCHLD, skip_signal); 267286470930SIngo Molnar signal(SIGALRM, skip_signal); 267386470930SIngo Molnar signal(SIGABRT, skip_signal); 267486470930SIngo Molnar 267542202dd5SIngo Molnar status = 0; 2676a7e191c3SFrederik Deweerdt for (run_idx = 0; forever || run_idx < run_count; run_idx++) { 2677bb963e16SNamhyung Kim if (run_count != 1 && verbose > 0) 26784aa9015fSStephane Eranian fprintf(output, "[ perf stat: executing run #%d ... ]\n", 26794aa9015fSStephane Eranian run_idx + 1); 2680f9cef0a9SIngo Molnar 268142202dd5SIngo Molnar status = run_perf_stat(argc, argv); 2682a7e191c3SFrederik Deweerdt if (forever && status != -1) { 2683d4f63a47SJiri Olsa print_counters(NULL, argc, argv); 2684254ecbc7SJiri Olsa perf_stat__reset_stats(); 2685a7e191c3SFrederik Deweerdt } 268642202dd5SIngo Molnar } 268742202dd5SIngo Molnar 2688a7e191c3SFrederik Deweerdt if (!forever && status != -1 && !interval) 2689d4f63a47SJiri Olsa print_counters(NULL, argc, argv); 2690d134ffb9SArnaldo Carvalho de Melo 26914979d0c7SJiri Olsa if (STAT_RECORD) { 26924979d0c7SJiri Olsa /* 26934979d0c7SJiri Olsa * We synthesize the kernel mmap record just so that older tools 26944979d0c7SJiri Olsa * don't emit warnings about not being able to resolve symbols 26954979d0c7SJiri Olsa * due to /proc/sys/kernel/kptr_restrict settings and instear provide 26964979d0c7SJiri Olsa * a saner message about no samples being in the perf.data file. 26974979d0c7SJiri Olsa * 26984979d0c7SJiri Olsa * This also serves to suppress a warning about f_header.data.size == 0 26998b99b1a4SJiri Olsa * in header.c at the moment 'perf stat record' gets introduced, which 27008b99b1a4SJiri Olsa * is not really needed once we start adding the stat specific PERF_RECORD_ 27018b99b1a4SJiri Olsa * records, but the need to suppress the kptr_restrict messages in older 27028b99b1a4SJiri Olsa * tools remain -acme 27034979d0c7SJiri Olsa */ 27044979d0c7SJiri Olsa int fd = perf_data_file__fd(&perf_stat.file); 27054979d0c7SJiri Olsa int err = perf_event__synthesize_kernel_mmap((void *)&perf_stat, 27064979d0c7SJiri Olsa process_synthesized_event, 27074979d0c7SJiri Olsa &perf_stat.session->machines.host); 27084979d0c7SJiri Olsa if (err) { 27094979d0c7SJiri Olsa pr_warning("Couldn't synthesize the kernel mmap record, harmless, " 27104979d0c7SJiri Olsa "older tools may produce warnings about this file\n."); 27114979d0c7SJiri Olsa } 27124979d0c7SJiri Olsa 27137aad0c32SJiri Olsa if (!interval) { 27147aad0c32SJiri Olsa if (WRITE_STAT_ROUND_EVENT(walltime_nsecs_stats.max, FINAL)) 27157aad0c32SJiri Olsa pr_err("failed to write stat round event\n"); 27167aad0c32SJiri Olsa } 27177aad0c32SJiri Olsa 2718664c98d4SJiri Olsa if (!perf_stat.file.is_pipe) { 27194979d0c7SJiri Olsa perf_stat.session->header.data_size += perf_stat.bytes_written; 27204979d0c7SJiri Olsa perf_session__write_header(perf_stat.session, evsel_list, fd, true); 2721664c98d4SJiri Olsa } 27224979d0c7SJiri Olsa 27234979d0c7SJiri Olsa perf_session__delete(perf_stat.session); 27244979d0c7SJiri Olsa } 27254979d0c7SJiri Olsa 2726544c2ae7SMasami Hiramatsu perf_stat__exit_aggr_mode(); 2727d134ffb9SArnaldo Carvalho de Melo perf_evlist__free_stats(evsel_list); 27280015e2e1SArnaldo Carvalho de Melo out: 27290015e2e1SArnaldo Carvalho de Melo perf_evlist__delete(evsel_list); 273042202dd5SIngo Molnar return status; 273186470930SIngo Molnar } 2732