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" 4886470930SIngo Molnar #include "util/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" 55a5d243d0SIngo Molnar #include "util/color.h" 560007eceaSXiao Guangrong #include "util/stat.h" 5760666c63SLiming Wang #include "util/header.h" 58a12b51c4SPaul Mackerras #include "util/cpumap.h" 59d6d901c2SZhang, Yanmin #include "util/thread.h" 60fd78260bSArnaldo Carvalho de Melo #include "util/thread_map.h" 6186470930SIngo Molnar 621f16c575SPeter Zijlstra #include <stdlib.h> 6386470930SIngo Molnar #include <sys/prctl.h> 645af52b51SStephane Eranian #include <locale.h> 6586470930SIngo Molnar 66d7470b6aSStephane Eranian #define DEFAULT_SEPARATOR " " 672cee77c4SDavid Ahern #define CNTR_NOT_SUPPORTED "<not supported>" 682cee77c4SDavid Ahern #define CNTR_NOT_COUNTED "<not counted>" 69d7470b6aSStephane Eranian 7013370a9bSStephane Eranian static void print_stat(int argc, const char **argv); 7113370a9bSStephane Eranian static void print_counter_aggr(struct perf_evsel *counter, char *prefix); 7213370a9bSStephane Eranian static void print_counter(struct perf_evsel *counter, char *prefix); 7386ee6e18SStephane Eranian static void print_aggr(char *prefix); 7413370a9bSStephane Eranian 754cabc3d1SAndi Kleen /* Default events used for perf stat -T */ 764cabc3d1SAndi Kleen static const char * const transaction_attrs[] = { 774cabc3d1SAndi Kleen "task-clock", 784cabc3d1SAndi Kleen "{" 794cabc3d1SAndi Kleen "instructions," 804cabc3d1SAndi Kleen "cycles," 814cabc3d1SAndi Kleen "cpu/cycles-t/," 824cabc3d1SAndi Kleen "cpu/tx-start/," 834cabc3d1SAndi Kleen "cpu/el-start/," 844cabc3d1SAndi Kleen "cpu/cycles-ct/" 854cabc3d1SAndi Kleen "}" 864cabc3d1SAndi Kleen }; 874cabc3d1SAndi Kleen 884cabc3d1SAndi Kleen /* More limited version when the CPU does not have all events. */ 894cabc3d1SAndi Kleen static const char * const transaction_limited_attrs[] = { 904cabc3d1SAndi Kleen "task-clock", 914cabc3d1SAndi Kleen "{" 924cabc3d1SAndi Kleen "instructions," 934cabc3d1SAndi Kleen "cycles," 944cabc3d1SAndi Kleen "cpu/cycles-t/," 954cabc3d1SAndi Kleen "cpu/tx-start/" 964cabc3d1SAndi Kleen "}" 974cabc3d1SAndi Kleen }; 984cabc3d1SAndi Kleen 994cabc3d1SAndi Kleen /* must match transaction_attrs and the beginning limited_attrs */ 1004cabc3d1SAndi Kleen enum { 1014cabc3d1SAndi Kleen T_TASK_CLOCK, 1024cabc3d1SAndi Kleen T_INSTRUCTIONS, 1034cabc3d1SAndi Kleen T_CYCLES, 1044cabc3d1SAndi Kleen T_CYCLES_IN_TX, 1054cabc3d1SAndi Kleen T_TRANSACTION_START, 1064cabc3d1SAndi Kleen T_ELISION_START, 1074cabc3d1SAndi Kleen T_CYCLES_IN_TX_CP, 1084cabc3d1SAndi Kleen }; 1094cabc3d1SAndi Kleen 110666e6d48SRobert Richter static struct perf_evlist *evsel_list; 111361c99a6SArnaldo Carvalho de Melo 112602ad878SArnaldo Carvalho de Melo static struct target target = { 11377a6f014SNamhyung Kim .uid = UINT_MAX, 11477a6f014SNamhyung Kim }; 11542202dd5SIngo Molnar 11686ee6e18SStephane Eranian enum aggr_mode { 11786ee6e18SStephane Eranian AGGR_NONE, 11886ee6e18SStephane Eranian AGGR_GLOBAL, 11986ee6e18SStephane Eranian AGGR_SOCKET, 12012c08a9fSStephane Eranian AGGR_CORE, 12186ee6e18SStephane Eranian }; 12286ee6e18SStephane Eranian 1233d632595SJaswinder Singh Rajput static int run_count = 1; 1242e6cdf99SStephane Eranian static bool no_inherit = false; 125c0555642SIan Munsie static bool scale = true; 12686ee6e18SStephane Eranian static enum aggr_mode aggr_mode = AGGR_GLOBAL; 127d07f0b12SStephane Eranian static volatile pid_t child_pid = -1; 128c0555642SIan Munsie static bool null_run = false; 1292cba3ffbSIngo Molnar static int detailed_run = 0; 1304cabc3d1SAndi Kleen static bool transaction_run; 131201e0b06SArnaldo Carvalho de Melo static bool big_num = true; 132d7470b6aSStephane Eranian static int big_num_opt = -1; 133d7470b6aSStephane Eranian static const char *csv_sep = NULL; 134d7470b6aSStephane Eranian static bool csv_output = false; 13543bece79SLin Ming static bool group = false; 1364aa9015fSStephane Eranian static FILE *output = NULL; 1371f16c575SPeter Zijlstra static const char *pre_cmd = NULL; 1381f16c575SPeter Zijlstra static const char *post_cmd = NULL; 1391f16c575SPeter Zijlstra static bool sync_run = false; 14013370a9bSStephane Eranian static unsigned int interval = 0; 14141191688SAndi Kleen static unsigned int initial_delay = 0; 142410136f5SStephane Eranian static unsigned int unit_width = 4; /* strlen("unit") */ 143a7e191c3SFrederik Deweerdt static bool forever = false; 14413370a9bSStephane Eranian static struct timespec ref_time; 14586ee6e18SStephane Eranian static struct cpu_map *aggr_map; 14686ee6e18SStephane Eranian static int (*aggr_get_id)(struct cpu_map *m, int cpu); 1475af52b51SStephane Eranian 14860666c63SLiming Wang static volatile int done = 0; 14960666c63SLiming Wang 15069aad6f1SArnaldo Carvalho de Melo struct perf_stat { 15169aad6f1SArnaldo Carvalho de Melo struct stats res_stats[3]; 15269aad6f1SArnaldo Carvalho de Melo }; 15369aad6f1SArnaldo Carvalho de Melo 15413370a9bSStephane Eranian static inline void diff_timespec(struct timespec *r, struct timespec *a, 15513370a9bSStephane Eranian struct timespec *b) 15613370a9bSStephane Eranian { 15713370a9bSStephane Eranian r->tv_sec = a->tv_sec - b->tv_sec; 15813370a9bSStephane Eranian if (a->tv_nsec < b->tv_nsec) { 15913370a9bSStephane Eranian r->tv_nsec = a->tv_nsec + 1000000000L - b->tv_nsec; 16013370a9bSStephane Eranian r->tv_sec--; 16113370a9bSStephane Eranian } else { 16213370a9bSStephane Eranian r->tv_nsec = a->tv_nsec - b->tv_nsec ; 16313370a9bSStephane Eranian } 16413370a9bSStephane Eranian } 16513370a9bSStephane Eranian 16613370a9bSStephane Eranian static inline struct cpu_map *perf_evsel__cpus(struct perf_evsel *evsel) 16713370a9bSStephane Eranian { 16813370a9bSStephane Eranian return (evsel->cpus && !target.cpu_list) ? evsel->cpus : evsel_list->cpus; 16913370a9bSStephane Eranian } 17013370a9bSStephane Eranian 17113370a9bSStephane Eranian static inline int perf_evsel__nr_cpus(struct perf_evsel *evsel) 17213370a9bSStephane Eranian { 17313370a9bSStephane Eranian return perf_evsel__cpus(evsel)->nr; 17413370a9bSStephane Eranian } 17513370a9bSStephane Eranian 176a7e191c3SFrederik Deweerdt static void perf_evsel__reset_stat_priv(struct perf_evsel *evsel) 177a7e191c3SFrederik Deweerdt { 17890f6bb6cSAndi Kleen int i; 17990f6bb6cSAndi Kleen struct perf_stat *ps = evsel->priv; 18090f6bb6cSAndi Kleen 18190f6bb6cSAndi Kleen for (i = 0; i < 3; i++) 18290f6bb6cSAndi Kleen init_stats(&ps->res_stats[i]); 183a7e191c3SFrederik Deweerdt } 184a7e191c3SFrederik Deweerdt 185c52b12edSArnaldo Carvalho de Melo static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel) 18669aad6f1SArnaldo Carvalho de Melo { 187c52b12edSArnaldo Carvalho de Melo evsel->priv = zalloc(sizeof(struct perf_stat)); 188d180ac14SJiri Olsa if (evsel->priv == NULL) 18990f6bb6cSAndi Kleen return -ENOMEM; 19090f6bb6cSAndi Kleen perf_evsel__reset_stat_priv(evsel); 19190f6bb6cSAndi Kleen return 0; 19269aad6f1SArnaldo Carvalho de Melo } 19369aad6f1SArnaldo Carvalho de Melo 19469aad6f1SArnaldo Carvalho de Melo static void perf_evsel__free_stat_priv(struct perf_evsel *evsel) 19569aad6f1SArnaldo Carvalho de Melo { 19604662523SArnaldo Carvalho de Melo zfree(&evsel->priv); 19769aad6f1SArnaldo Carvalho de Melo } 19869aad6f1SArnaldo Carvalho de Melo 19913370a9bSStephane Eranian static int perf_evsel__alloc_prev_raw_counts(struct perf_evsel *evsel) 2007ae92e74SYan, Zheng { 20113370a9bSStephane Eranian void *addr; 20213370a9bSStephane Eranian size_t sz; 20313370a9bSStephane Eranian 20413370a9bSStephane Eranian sz = sizeof(*evsel->counts) + 20513370a9bSStephane Eranian (perf_evsel__nr_cpus(evsel) * sizeof(struct perf_counts_values)); 20613370a9bSStephane Eranian 20713370a9bSStephane Eranian addr = zalloc(sz); 20813370a9bSStephane Eranian if (!addr) 20913370a9bSStephane Eranian return -ENOMEM; 21013370a9bSStephane Eranian 21113370a9bSStephane Eranian evsel->prev_raw_counts = addr; 21213370a9bSStephane Eranian 21313370a9bSStephane Eranian return 0; 2147ae92e74SYan, Zheng } 2157ae92e74SYan, Zheng 21613370a9bSStephane Eranian static void perf_evsel__free_prev_raw_counts(struct perf_evsel *evsel) 2177ae92e74SYan, Zheng { 21804662523SArnaldo Carvalho de Melo zfree(&evsel->prev_raw_counts); 2197ae92e74SYan, Zheng } 2207ae92e74SYan, Zheng 221d134ffb9SArnaldo Carvalho de Melo static void perf_evlist__free_stats(struct perf_evlist *evlist) 222d134ffb9SArnaldo Carvalho de Melo { 223d134ffb9SArnaldo Carvalho de Melo struct perf_evsel *evsel; 224d134ffb9SArnaldo Carvalho de Melo 2250050f7aaSArnaldo Carvalho de Melo evlist__for_each(evlist, evsel) { 226d134ffb9SArnaldo Carvalho de Melo perf_evsel__free_stat_priv(evsel); 227d134ffb9SArnaldo Carvalho de Melo perf_evsel__free_counts(evsel); 228d134ffb9SArnaldo Carvalho de Melo perf_evsel__free_prev_raw_counts(evsel); 229d134ffb9SArnaldo Carvalho de Melo } 230d134ffb9SArnaldo Carvalho de Melo } 231d134ffb9SArnaldo Carvalho de Melo 232d134ffb9SArnaldo Carvalho de Melo static int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw) 233d134ffb9SArnaldo Carvalho de Melo { 234d134ffb9SArnaldo Carvalho de Melo struct perf_evsel *evsel; 235d134ffb9SArnaldo Carvalho de Melo 2360050f7aaSArnaldo Carvalho de Melo evlist__for_each(evlist, evsel) { 237d134ffb9SArnaldo Carvalho de Melo if (perf_evsel__alloc_stat_priv(evsel) < 0 || 238d134ffb9SArnaldo Carvalho de Melo perf_evsel__alloc_counts(evsel, perf_evsel__nr_cpus(evsel)) < 0 || 239d134ffb9SArnaldo Carvalho de Melo (alloc_raw && perf_evsel__alloc_prev_raw_counts(evsel) < 0)) 240d134ffb9SArnaldo Carvalho de Melo goto out_free; 241d134ffb9SArnaldo Carvalho de Melo } 242d134ffb9SArnaldo Carvalho de Melo 243d134ffb9SArnaldo Carvalho de Melo return 0; 244d134ffb9SArnaldo Carvalho de Melo 245d134ffb9SArnaldo Carvalho de Melo out_free: 246d134ffb9SArnaldo Carvalho de Melo perf_evlist__free_stats(evlist); 247d134ffb9SArnaldo Carvalho de Melo return -1; 248d134ffb9SArnaldo Carvalho de Melo } 249d134ffb9SArnaldo Carvalho de Melo 250666e6d48SRobert Richter static struct stats runtime_nsecs_stats[MAX_NR_CPUS]; 251666e6d48SRobert Richter static struct stats runtime_cycles_stats[MAX_NR_CPUS]; 252666e6d48SRobert Richter static struct stats runtime_stalled_cycles_front_stats[MAX_NR_CPUS]; 253666e6d48SRobert Richter static struct stats runtime_stalled_cycles_back_stats[MAX_NR_CPUS]; 254666e6d48SRobert Richter static struct stats runtime_branches_stats[MAX_NR_CPUS]; 255666e6d48SRobert Richter static struct stats runtime_cacherefs_stats[MAX_NR_CPUS]; 256666e6d48SRobert Richter static struct stats runtime_l1_dcache_stats[MAX_NR_CPUS]; 257666e6d48SRobert Richter static struct stats runtime_l1_icache_stats[MAX_NR_CPUS]; 258666e6d48SRobert Richter static struct stats runtime_ll_cache_stats[MAX_NR_CPUS]; 259666e6d48SRobert Richter static struct stats runtime_itlb_cache_stats[MAX_NR_CPUS]; 260666e6d48SRobert Richter static struct stats runtime_dtlb_cache_stats[MAX_NR_CPUS]; 2614cabc3d1SAndi Kleen static struct stats runtime_cycles_in_tx_stats[MAX_NR_CPUS]; 262666e6d48SRobert Richter static struct stats walltime_nsecs_stats; 2634cabc3d1SAndi Kleen static struct stats runtime_transaction_stats[MAX_NR_CPUS]; 2644cabc3d1SAndi Kleen static struct stats runtime_elision_stats[MAX_NR_CPUS]; 26586470930SIngo Molnar 266d134ffb9SArnaldo Carvalho de Melo static void perf_stat__reset_stats(struct perf_evlist *evlist) 267a7e191c3SFrederik Deweerdt { 268d134ffb9SArnaldo Carvalho de Melo struct perf_evsel *evsel; 269d134ffb9SArnaldo Carvalho de Melo 2700050f7aaSArnaldo Carvalho de Melo evlist__for_each(evlist, evsel) { 271d134ffb9SArnaldo Carvalho de Melo perf_evsel__reset_stat_priv(evsel); 272d134ffb9SArnaldo Carvalho de Melo perf_evsel__reset_counts(evsel, perf_evsel__nr_cpus(evsel)); 273d134ffb9SArnaldo Carvalho de Melo } 274d134ffb9SArnaldo Carvalho de Melo 275a7e191c3SFrederik Deweerdt memset(runtime_nsecs_stats, 0, sizeof(runtime_nsecs_stats)); 276a7e191c3SFrederik Deweerdt memset(runtime_cycles_stats, 0, sizeof(runtime_cycles_stats)); 277a7e191c3SFrederik Deweerdt memset(runtime_stalled_cycles_front_stats, 0, sizeof(runtime_stalled_cycles_front_stats)); 278a7e191c3SFrederik Deweerdt memset(runtime_stalled_cycles_back_stats, 0, sizeof(runtime_stalled_cycles_back_stats)); 279a7e191c3SFrederik Deweerdt memset(runtime_branches_stats, 0, sizeof(runtime_branches_stats)); 280a7e191c3SFrederik Deweerdt memset(runtime_cacherefs_stats, 0, sizeof(runtime_cacherefs_stats)); 281a7e191c3SFrederik Deweerdt memset(runtime_l1_dcache_stats, 0, sizeof(runtime_l1_dcache_stats)); 282a7e191c3SFrederik Deweerdt memset(runtime_l1_icache_stats, 0, sizeof(runtime_l1_icache_stats)); 283a7e191c3SFrederik Deweerdt memset(runtime_ll_cache_stats, 0, sizeof(runtime_ll_cache_stats)); 284a7e191c3SFrederik Deweerdt memset(runtime_itlb_cache_stats, 0, sizeof(runtime_itlb_cache_stats)); 285a7e191c3SFrederik Deweerdt memset(runtime_dtlb_cache_stats, 0, sizeof(runtime_dtlb_cache_stats)); 2864cabc3d1SAndi Kleen memset(runtime_cycles_in_tx_stats, 0, 2874cabc3d1SAndi Kleen sizeof(runtime_cycles_in_tx_stats)); 2884cabc3d1SAndi Kleen memset(runtime_transaction_stats, 0, 2894cabc3d1SAndi Kleen sizeof(runtime_transaction_stats)); 2904cabc3d1SAndi Kleen memset(runtime_elision_stats, 0, sizeof(runtime_elision_stats)); 291a7e191c3SFrederik Deweerdt memset(&walltime_nsecs_stats, 0, sizeof(walltime_nsecs_stats)); 292a7e191c3SFrederik Deweerdt } 293a7e191c3SFrederik Deweerdt 294cac21425SJiri Olsa static int create_perf_stat_counter(struct perf_evsel *evsel) 29586470930SIngo Molnar { 29669aad6f1SArnaldo Carvalho de Melo struct perf_event_attr *attr = &evsel->attr; 297727ab04eSArnaldo Carvalho de Melo 29886470930SIngo Molnar if (scale) 29986470930SIngo Molnar attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | 30086470930SIngo Molnar PERF_FORMAT_TOTAL_TIME_RUNNING; 30186470930SIngo Molnar 3022e6cdf99SStephane Eranian attr->inherit = !no_inherit; 3035d2cd909SArnaldo Carvalho de Melo 304602ad878SArnaldo Carvalho de Melo if (target__has_cpu(&target)) 305594ac61aSArnaldo Carvalho de Melo return perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel)); 3065622c07bSStephane Eranian 307602ad878SArnaldo Carvalho de Melo if (!target__has_task(&target) && perf_evsel__is_group_leader(evsel)) { 30886470930SIngo Molnar attr->disabled = 1; 30941191688SAndi Kleen if (!initial_delay) 31057e7986eSPaul Mackerras attr->enable_on_exec = 1; 3116be2850eSZhang, Yanmin } 312084ab9f8SArnaldo Carvalho de Melo 313594ac61aSArnaldo Carvalho de Melo return perf_evsel__open_per_thread(evsel, evsel_list->threads); 31486470930SIngo Molnar } 31586470930SIngo Molnar 31686470930SIngo Molnar /* 31786470930SIngo Molnar * Does the counter have nsecs as a unit? 31886470930SIngo Molnar */ 319daec78a0SArnaldo Carvalho de Melo static inline int nsec_counter(struct perf_evsel *evsel) 32086470930SIngo Molnar { 321daec78a0SArnaldo Carvalho de Melo if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) || 322daec78a0SArnaldo Carvalho de Melo perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK)) 32386470930SIngo Molnar return 1; 32486470930SIngo Molnar 32586470930SIngo Molnar return 0; 32686470930SIngo Molnar } 32786470930SIngo Molnar 3284cabc3d1SAndi Kleen static struct perf_evsel *nth_evsel(int n) 3294cabc3d1SAndi Kleen { 3304cabc3d1SAndi Kleen static struct perf_evsel **array; 3314cabc3d1SAndi Kleen static int array_len; 3324cabc3d1SAndi Kleen struct perf_evsel *ev; 3334cabc3d1SAndi Kleen int j; 3344cabc3d1SAndi Kleen 3354cabc3d1SAndi Kleen /* Assumes this only called when evsel_list does not change anymore. */ 3364cabc3d1SAndi Kleen if (!array) { 3370050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, ev) 3384cabc3d1SAndi Kleen array_len++; 3394cabc3d1SAndi Kleen array = malloc(array_len * sizeof(void *)); 3404cabc3d1SAndi Kleen if (!array) 3414cabc3d1SAndi Kleen exit(ENOMEM); 3424cabc3d1SAndi Kleen j = 0; 3430050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, ev) 3444cabc3d1SAndi Kleen array[j++] = ev; 3454cabc3d1SAndi Kleen } 3464cabc3d1SAndi Kleen if (n < array_len) 3474cabc3d1SAndi Kleen return array[n]; 3484cabc3d1SAndi Kleen return NULL; 3494cabc3d1SAndi Kleen } 3504cabc3d1SAndi Kleen 35186470930SIngo Molnar /* 352dcd9936aSIngo Molnar * Update various tracking values we maintain to print 353dcd9936aSIngo Molnar * more semantic information such as miss/hit ratios, 354dcd9936aSIngo Molnar * instruction rates, etc: 355dcd9936aSIngo Molnar */ 356dcd9936aSIngo Molnar static void update_shadow_stats(struct perf_evsel *counter, u64 *count) 357dcd9936aSIngo Molnar { 358dcd9936aSIngo Molnar if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK)) 359dcd9936aSIngo Molnar update_stats(&runtime_nsecs_stats[0], count[0]); 360dcd9936aSIngo Molnar else if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES)) 361dcd9936aSIngo Molnar update_stats(&runtime_cycles_stats[0], count[0]); 3624cabc3d1SAndi Kleen else if (transaction_run && 3634cabc3d1SAndi Kleen perf_evsel__cmp(counter, nth_evsel(T_CYCLES_IN_TX))) 3644cabc3d1SAndi Kleen update_stats(&runtime_cycles_in_tx_stats[0], count[0]); 3654cabc3d1SAndi Kleen else if (transaction_run && 3664cabc3d1SAndi Kleen perf_evsel__cmp(counter, nth_evsel(T_TRANSACTION_START))) 3674cabc3d1SAndi Kleen update_stats(&runtime_transaction_stats[0], count[0]); 3684cabc3d1SAndi Kleen else if (transaction_run && 3694cabc3d1SAndi Kleen perf_evsel__cmp(counter, nth_evsel(T_ELISION_START))) 3704cabc3d1SAndi Kleen update_stats(&runtime_elision_stats[0], count[0]); 371d3d1e86dSIngo Molnar else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) 372d3d1e86dSIngo Molnar update_stats(&runtime_stalled_cycles_front_stats[0], count[0]); 373129c04cbSIngo Molnar else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND)) 374d3d1e86dSIngo Molnar update_stats(&runtime_stalled_cycles_back_stats[0], count[0]); 375dcd9936aSIngo Molnar else if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS)) 376dcd9936aSIngo Molnar update_stats(&runtime_branches_stats[0], count[0]); 377dcd9936aSIngo Molnar else if (perf_evsel__match(counter, HARDWARE, HW_CACHE_REFERENCES)) 378dcd9936aSIngo Molnar update_stats(&runtime_cacherefs_stats[0], count[0]); 3798bb6c79fSIngo Molnar else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1D)) 3808bb6c79fSIngo Molnar update_stats(&runtime_l1_dcache_stats[0], count[0]); 381c3305257SIngo Molnar else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_L1I)) 382c3305257SIngo Molnar update_stats(&runtime_l1_icache_stats[0], count[0]); 383c3305257SIngo Molnar else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_LL)) 384c3305257SIngo Molnar update_stats(&runtime_ll_cache_stats[0], count[0]); 385c3305257SIngo Molnar else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_DTLB)) 386c3305257SIngo Molnar update_stats(&runtime_dtlb_cache_stats[0], count[0]); 387c3305257SIngo Molnar else if (perf_evsel__match(counter, HW_CACHE, HW_CACHE_ITLB)) 388c3305257SIngo Molnar update_stats(&runtime_itlb_cache_stats[0], count[0]); 389dcd9936aSIngo Molnar } 390dcd9936aSIngo Molnar 391060c4f9cSJiri Olsa static int read_cb(struct perf_evsel *evsel, int cpu, int thread __maybe_unused, 392060c4f9cSJiri Olsa struct perf_counts_values *count) 393060c4f9cSJiri Olsa { 394060c4f9cSJiri Olsa switch (aggr_mode) { 395060c4f9cSJiri Olsa case AGGR_CORE: 396060c4f9cSJiri Olsa case AGGR_SOCKET: 397060c4f9cSJiri Olsa case AGGR_NONE: 398060c4f9cSJiri Olsa perf_evsel__compute_deltas(evsel, cpu, count); 399060c4f9cSJiri Olsa perf_counts_values__scale(count, scale, NULL); 400060c4f9cSJiri Olsa evsel->counts->cpu[cpu] = *count; 401060c4f9cSJiri Olsa update_shadow_stats(evsel, count->values); 402060c4f9cSJiri Olsa break; 403060c4f9cSJiri Olsa case AGGR_GLOBAL: 404060c4f9cSJiri Olsa default: 405060c4f9cSJiri Olsa break; 406060c4f9cSJiri Olsa } 407060c4f9cSJiri Olsa 408060c4f9cSJiri Olsa return 0; 409060c4f9cSJiri Olsa } 410060c4f9cSJiri Olsa 411dcd9936aSIngo Molnar /* 41286470930SIngo Molnar * Read out the results of a single counter: 413f5b4a9c3SStephane Eranian * aggregate counts across CPUs in system-wide mode 41486470930SIngo Molnar */ 415c52b12edSArnaldo Carvalho de Melo static int read_counter_aggr(struct perf_evsel *counter) 41686470930SIngo Molnar { 41769aad6f1SArnaldo Carvalho de Melo struct perf_stat *ps = counter->priv; 418c52b12edSArnaldo Carvalho de Melo u64 *count = counter->counts->aggr.values; 419c52b12edSArnaldo Carvalho de Melo int i; 42086470930SIngo Molnar 4217ae92e74SYan, Zheng if (__perf_evsel__read(counter, perf_evsel__nr_cpus(counter), 422b3a319d5SNamhyung Kim thread_map__nr(evsel_list->threads), scale) < 0) 423c52b12edSArnaldo Carvalho de Melo return -1; 4249e9772c4SPeter Zijlstra 4259e9772c4SPeter Zijlstra for (i = 0; i < 3; i++) 42669aad6f1SArnaldo Carvalho de Melo update_stats(&ps->res_stats[i], count[i]); 4279e9772c4SPeter Zijlstra 4289e9772c4SPeter Zijlstra if (verbose) { 4294aa9015fSStephane Eranian fprintf(output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n", 4307289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter), count[0], count[1], count[2]); 4319e9772c4SPeter Zijlstra } 4329e9772c4SPeter Zijlstra 43386470930SIngo Molnar /* 43486470930SIngo Molnar * Save the full runtime - to allow normalization during printout: 43586470930SIngo Molnar */ 436dcd9936aSIngo Molnar update_shadow_stats(counter, count); 437c52b12edSArnaldo Carvalho de Melo 438c52b12edSArnaldo Carvalho de Melo return 0; 439f5b4a9c3SStephane Eranian } 440f5b4a9c3SStephane Eranian 441f5b4a9c3SStephane Eranian /* 442f5b4a9c3SStephane Eranian * Read out the results of a single counter: 443f5b4a9c3SStephane Eranian * do not aggregate counts across CPUs in system-wide mode 444f5b4a9c3SStephane Eranian */ 445c52b12edSArnaldo Carvalho de Melo static int read_counter(struct perf_evsel *counter) 446f5b4a9c3SStephane Eranian { 4479bf1a529SJiri Olsa int nthreads = thread_map__nr(evsel_list->threads); 4489bf1a529SJiri Olsa int ncpus = perf_evsel__nr_cpus(counter); 4499bf1a529SJiri Olsa int cpu, thread; 450f5b4a9c3SStephane Eranian 4519bf1a529SJiri Olsa if (counter->system_wide) 4529bf1a529SJiri Olsa nthreads = 1; 4539bf1a529SJiri Olsa 4549bf1a529SJiri Olsa for (thread = 0; thread < nthreads; thread++) { 4559bf1a529SJiri Olsa for (cpu = 0; cpu < ncpus; cpu++) { 4569bf1a529SJiri Olsa if (perf_evsel__read_cb(counter, cpu, thread, read_cb)) 457c52b12edSArnaldo Carvalho de Melo return -1; 458f5b4a9c3SStephane Eranian } 4599bf1a529SJiri Olsa } 460c52b12edSArnaldo Carvalho de Melo 461c52b12edSArnaldo Carvalho de Melo return 0; 46286470930SIngo Molnar } 46386470930SIngo Molnar 46413370a9bSStephane Eranian static void print_interval(void) 46513370a9bSStephane Eranian { 46613370a9bSStephane Eranian static int num_print_interval; 46713370a9bSStephane Eranian struct perf_evsel *counter; 46813370a9bSStephane Eranian struct perf_stat *ps; 46913370a9bSStephane Eranian struct timespec ts, rs; 47013370a9bSStephane Eranian char prefix[64]; 47113370a9bSStephane Eranian 47286ee6e18SStephane Eranian if (aggr_mode == AGGR_GLOBAL) { 4730050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 47413370a9bSStephane Eranian ps = counter->priv; 47513370a9bSStephane Eranian memset(ps->res_stats, 0, sizeof(ps->res_stats)); 47613370a9bSStephane Eranian read_counter_aggr(counter); 47713370a9bSStephane Eranian } 47886ee6e18SStephane Eranian } else { 4790050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 48086ee6e18SStephane Eranian ps = counter->priv; 48186ee6e18SStephane Eranian memset(ps->res_stats, 0, sizeof(ps->res_stats)); 48286ee6e18SStephane Eranian read_counter(counter); 48313370a9bSStephane Eranian } 48486ee6e18SStephane Eranian } 48586ee6e18SStephane Eranian 48613370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ts); 48713370a9bSStephane Eranian diff_timespec(&rs, &ts, &ref_time); 48813370a9bSStephane Eranian sprintf(prefix, "%6lu.%09lu%s", rs.tv_sec, rs.tv_nsec, csv_sep); 48913370a9bSStephane Eranian 49013370a9bSStephane Eranian if (num_print_interval == 0 && !csv_output) { 49186ee6e18SStephane Eranian switch (aggr_mode) { 49286ee6e18SStephane Eranian case AGGR_SOCKET: 493410136f5SStephane Eranian fprintf(output, "# time socket cpus counts %*s events\n", unit_width, "unit"); 49486ee6e18SStephane Eranian break; 49512c08a9fSStephane Eranian case AGGR_CORE: 496410136f5SStephane Eranian fprintf(output, "# time core cpus counts %*s events\n", unit_width, "unit"); 49712c08a9fSStephane Eranian break; 49886ee6e18SStephane Eranian case AGGR_NONE: 499410136f5SStephane Eranian fprintf(output, "# time CPU counts %*s events\n", unit_width, "unit"); 50086ee6e18SStephane Eranian break; 50186ee6e18SStephane Eranian case AGGR_GLOBAL: 50286ee6e18SStephane Eranian default: 503410136f5SStephane Eranian fprintf(output, "# time counts %*s events\n", unit_width, "unit"); 50413370a9bSStephane Eranian } 50586ee6e18SStephane Eranian } 50613370a9bSStephane Eranian 50713370a9bSStephane Eranian if (++num_print_interval == 25) 50813370a9bSStephane Eranian num_print_interval = 0; 50913370a9bSStephane Eranian 51086ee6e18SStephane Eranian switch (aggr_mode) { 51112c08a9fSStephane Eranian case AGGR_CORE: 51286ee6e18SStephane Eranian case AGGR_SOCKET: 51386ee6e18SStephane Eranian print_aggr(prefix); 51486ee6e18SStephane Eranian break; 51586ee6e18SStephane Eranian case AGGR_NONE: 5160050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 51713370a9bSStephane Eranian print_counter(counter, prefix); 51886ee6e18SStephane Eranian break; 51986ee6e18SStephane Eranian case AGGR_GLOBAL: 52086ee6e18SStephane Eranian default: 5210050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 52213370a9bSStephane Eranian print_counter_aggr(counter, prefix); 52313370a9bSStephane Eranian } 5242bbf03f1SAndi Kleen 5252bbf03f1SAndi Kleen fflush(output); 52613370a9bSStephane Eranian } 52713370a9bSStephane Eranian 52841191688SAndi Kleen static void handle_initial_delay(void) 52941191688SAndi Kleen { 53041191688SAndi Kleen struct perf_evsel *counter; 53141191688SAndi Kleen 53241191688SAndi Kleen if (initial_delay) { 53341191688SAndi Kleen const int ncpus = cpu_map__nr(evsel_list->cpus), 53441191688SAndi Kleen nthreads = thread_map__nr(evsel_list->threads); 53541191688SAndi Kleen 53641191688SAndi Kleen usleep(initial_delay * 1000); 5370050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 53841191688SAndi Kleen perf_evsel__enable(counter, ncpus, nthreads); 53941191688SAndi Kleen } 54041191688SAndi Kleen } 54141191688SAndi Kleen 542f33cbe72SArnaldo Carvalho de Melo static volatile int workload_exec_errno; 5436af206fdSArnaldo Carvalho de Melo 5446af206fdSArnaldo Carvalho de Melo /* 5456af206fdSArnaldo Carvalho de Melo * perf_evlist__prepare_workload will send a SIGUSR1 5466af206fdSArnaldo Carvalho de Melo * if the fork fails, since we asked by setting its 5476af206fdSArnaldo Carvalho de Melo * want_signal to true. 5486af206fdSArnaldo Carvalho de Melo */ 549f33cbe72SArnaldo Carvalho de Melo static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info, 550f33cbe72SArnaldo Carvalho de Melo void *ucontext __maybe_unused) 5516af206fdSArnaldo Carvalho de Melo { 552f33cbe72SArnaldo Carvalho de Melo workload_exec_errno = info->si_value.sival_int; 5536af206fdSArnaldo Carvalho de Melo } 5546af206fdSArnaldo Carvalho de Melo 555acf28922SNamhyung Kim static int __run_perf_stat(int argc, const char **argv) 55686470930SIngo Molnar { 55756e52e85SArnaldo Carvalho de Melo char msg[512]; 55886470930SIngo Molnar unsigned long long t0, t1; 559cac21425SJiri Olsa struct perf_evsel *counter; 56013370a9bSStephane Eranian struct timespec ts; 561410136f5SStephane Eranian size_t l; 56242202dd5SIngo Molnar int status = 0; 5636be2850eSZhang, Yanmin const bool forks = (argc > 0); 56486470930SIngo Molnar 56513370a9bSStephane Eranian if (interval) { 56613370a9bSStephane Eranian ts.tv_sec = interval / 1000; 56713370a9bSStephane Eranian ts.tv_nsec = (interval % 1000) * 1000000; 56813370a9bSStephane Eranian } else { 56913370a9bSStephane Eranian ts.tv_sec = 1; 57013370a9bSStephane Eranian ts.tv_nsec = 0; 57113370a9bSStephane Eranian } 57213370a9bSStephane Eranian 573acf28922SNamhyung Kim if (forks) { 574735f7e0bSArnaldo Carvalho de Melo if (perf_evlist__prepare_workload(evsel_list, &target, argv, false, 575735f7e0bSArnaldo Carvalho de Melo workload_exec_failed_signal) < 0) { 576acf28922SNamhyung Kim perror("failed to prepare workload"); 577fceda7feSDavid Ahern return -1; 578051ae7f7SPaul Mackerras } 579d20a47e7SNamhyung Kim child_pid = evsel_list->workload.pid; 58060666c63SLiming Wang } 581051ae7f7SPaul Mackerras 5826a4bb04cSJiri Olsa if (group) 58363dab225SArnaldo Carvalho de Melo perf_evlist__set_leader(evsel_list); 5846a4bb04cSJiri Olsa 5850050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 586cac21425SJiri Olsa if (create_perf_stat_counter(counter) < 0) { 587979987a5SDavid Ahern /* 588979987a5SDavid Ahern * PPC returns ENXIO for HW counters until 2.6.37 589979987a5SDavid Ahern * (behavior changed with commit b0a873e). 590979987a5SDavid Ahern */ 59138f6ae1eSAnton Blanchard if (errno == EINVAL || errno == ENOSYS || 592979987a5SDavid Ahern errno == ENOENT || errno == EOPNOTSUPP || 593979987a5SDavid Ahern errno == ENXIO) { 594c63ca0c0SDavid Ahern if (verbose) 595c63ca0c0SDavid Ahern ui__warning("%s event is not supported by the kernel.\n", 5967289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 5972cee77c4SDavid Ahern counter->supported = false; 598ede70290SIngo Molnar continue; 599c63ca0c0SDavid Ahern } 600ede70290SIngo Molnar 60156e52e85SArnaldo Carvalho de Melo perf_evsel__open_strerror(counter, &target, 60256e52e85SArnaldo Carvalho de Melo errno, msg, sizeof(msg)); 60356e52e85SArnaldo Carvalho de Melo ui__error("%s\n", msg); 60456e52e85SArnaldo Carvalho de Melo 605084ab9f8SArnaldo Carvalho de Melo if (child_pid != -1) 606084ab9f8SArnaldo Carvalho de Melo kill(child_pid, SIGTERM); 607fceda7feSDavid Ahern 608084ab9f8SArnaldo Carvalho de Melo return -1; 609084ab9f8SArnaldo Carvalho de Melo } 6102cee77c4SDavid Ahern counter->supported = true; 611410136f5SStephane Eranian 612410136f5SStephane Eranian l = strlen(counter->unit); 613410136f5SStephane Eranian if (l > unit_width) 614410136f5SStephane Eranian unit_width = l; 61548290609SArnaldo Carvalho de Melo } 61686470930SIngo Molnar 6171491a632SArnaldo Carvalho de Melo if (perf_evlist__apply_filters(evsel_list)) { 618cfd748aeSFrederic Weisbecker error("failed to set filter with %d (%s)\n", errno, 619759e612bSMasami Hiramatsu strerror_r(errno, msg, sizeof(msg))); 620cfd748aeSFrederic Weisbecker return -1; 621cfd748aeSFrederic Weisbecker } 622cfd748aeSFrederic Weisbecker 62386470930SIngo Molnar /* 62486470930SIngo Molnar * Enable counters and exec the command: 62586470930SIngo Molnar */ 62686470930SIngo Molnar t0 = rdclock(); 62713370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ref_time); 62886470930SIngo Molnar 62960666c63SLiming Wang if (forks) { 630acf28922SNamhyung Kim perf_evlist__start_workload(evsel_list); 63141191688SAndi Kleen handle_initial_delay(); 632acf28922SNamhyung Kim 63313370a9bSStephane Eranian if (interval) { 63413370a9bSStephane Eranian while (!waitpid(child_pid, &status, WNOHANG)) { 63513370a9bSStephane Eranian nanosleep(&ts, NULL); 63613370a9bSStephane Eranian print_interval(); 63713370a9bSStephane Eranian } 63813370a9bSStephane Eranian } 63942202dd5SIngo Molnar wait(&status); 6406af206fdSArnaldo Carvalho de Melo 641f33cbe72SArnaldo Carvalho de Melo if (workload_exec_errno) { 642f33cbe72SArnaldo Carvalho de Melo const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg)); 643f33cbe72SArnaldo Carvalho de Melo pr_err("Workload failed: %s\n", emsg); 6446af206fdSArnaldo Carvalho de Melo return -1; 645f33cbe72SArnaldo Carvalho de Melo } 6466af206fdSArnaldo Carvalho de Melo 64733e49ea7SAndi Kleen if (WIFSIGNALED(status)) 64833e49ea7SAndi Kleen psignal(WTERMSIG(status), argv[0]); 64960666c63SLiming Wang } else { 65041191688SAndi Kleen handle_initial_delay(); 65113370a9bSStephane Eranian while (!done) { 65213370a9bSStephane Eranian nanosleep(&ts, NULL); 65313370a9bSStephane Eranian if (interval) 65413370a9bSStephane Eranian print_interval(); 65513370a9bSStephane Eranian } 65660666c63SLiming Wang } 65786470930SIngo Molnar 65886470930SIngo Molnar t1 = rdclock(); 65986470930SIngo Molnar 6609e9772c4SPeter Zijlstra update_stats(&walltime_nsecs_stats, t1 - t0); 66142202dd5SIngo Molnar 66286ee6e18SStephane Eranian if (aggr_mode == AGGR_GLOBAL) { 6630050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 664c52b12edSArnaldo Carvalho de Melo read_counter_aggr(counter); 6657ae92e74SYan, Zheng perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 666b3a319d5SNamhyung Kim thread_map__nr(evsel_list->threads)); 667c52b12edSArnaldo Carvalho de Melo } 66886ee6e18SStephane Eranian } else { 6690050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 67086ee6e18SStephane Eranian read_counter(counter); 67186ee6e18SStephane Eranian perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1); 67286ee6e18SStephane Eranian } 673c52b12edSArnaldo Carvalho de Melo } 674c52b12edSArnaldo Carvalho de Melo 67542202dd5SIngo Molnar return WEXITSTATUS(status); 67642202dd5SIngo Molnar } 67742202dd5SIngo Molnar 67841cde476SArnaldo Carvalho de Melo static int run_perf_stat(int argc, const char **argv) 6791f16c575SPeter Zijlstra { 6801f16c575SPeter Zijlstra int ret; 6811f16c575SPeter Zijlstra 6821f16c575SPeter Zijlstra if (pre_cmd) { 6831f16c575SPeter Zijlstra ret = system(pre_cmd); 6841f16c575SPeter Zijlstra if (ret) 6851f16c575SPeter Zijlstra return ret; 6861f16c575SPeter Zijlstra } 6871f16c575SPeter Zijlstra 6881f16c575SPeter Zijlstra if (sync_run) 6891f16c575SPeter Zijlstra sync(); 6901f16c575SPeter Zijlstra 6911f16c575SPeter Zijlstra ret = __run_perf_stat(argc, argv); 6921f16c575SPeter Zijlstra if (ret) 6931f16c575SPeter Zijlstra return ret; 6941f16c575SPeter Zijlstra 6951f16c575SPeter Zijlstra if (post_cmd) { 6961f16c575SPeter Zijlstra ret = system(post_cmd); 6971f16c575SPeter Zijlstra if (ret) 6981f16c575SPeter Zijlstra return ret; 6991f16c575SPeter Zijlstra } 7001f16c575SPeter Zijlstra 7011f16c575SPeter Zijlstra return ret; 7021f16c575SPeter Zijlstra } 7031f16c575SPeter Zijlstra 704f99844cbSIngo Molnar static void print_noise_pct(double total, double avg) 705f99844cbSIngo Molnar { 7060007eceaSXiao Guangrong double pct = rel_stddev_stats(total, avg); 707f99844cbSIngo Molnar 7083ae9a34dSZhengyu He if (csv_output) 7094aa9015fSStephane Eranian fprintf(output, "%s%.2f%%", csv_sep, pct); 710a1bca6ccSJim Cromie else if (pct) 7114aa9015fSStephane Eranian fprintf(output, " ( +-%6.2f%% )", pct); 712f99844cbSIngo Molnar } 713f99844cbSIngo Molnar 71469aad6f1SArnaldo Carvalho de Melo static void print_noise(struct perf_evsel *evsel, double avg) 71542202dd5SIngo Molnar { 71669aad6f1SArnaldo Carvalho de Melo struct perf_stat *ps; 71769aad6f1SArnaldo Carvalho de Melo 718849abde9SPeter Zijlstra if (run_count == 1) 719849abde9SPeter Zijlstra return; 720849abde9SPeter Zijlstra 72169aad6f1SArnaldo Carvalho de Melo ps = evsel->priv; 722f99844cbSIngo Molnar print_noise_pct(stddev_stats(&ps->res_stats[0]), avg); 72342202dd5SIngo Molnar } 72442202dd5SIngo Molnar 72512c08a9fSStephane Eranian static void aggr_printout(struct perf_evsel *evsel, int id, int nr) 72642202dd5SIngo Molnar { 72786ee6e18SStephane Eranian switch (aggr_mode) { 72812c08a9fSStephane Eranian case AGGR_CORE: 72912c08a9fSStephane Eranian fprintf(output, "S%d-C%*d%s%*d%s", 73012c08a9fSStephane Eranian cpu_map__id_to_socket(id), 73112c08a9fSStephane Eranian csv_output ? 0 : -8, 73212c08a9fSStephane Eranian cpu_map__id_to_cpu(id), 73312c08a9fSStephane Eranian csv_sep, 73412c08a9fSStephane Eranian csv_output ? 0 : 4, 73512c08a9fSStephane Eranian nr, 73612c08a9fSStephane Eranian csv_sep); 73712c08a9fSStephane Eranian break; 73886ee6e18SStephane Eranian case AGGR_SOCKET: 73986ee6e18SStephane Eranian fprintf(output, "S%*d%s%*d%s", 740d7e7a451SStephane Eranian csv_output ? 0 : -5, 74112c08a9fSStephane Eranian id, 742d7e7a451SStephane Eranian csv_sep, 743d7e7a451SStephane Eranian csv_output ? 0 : 4, 744d7e7a451SStephane Eranian nr, 745d7e7a451SStephane Eranian csv_sep); 74686ee6e18SStephane Eranian break; 74786ee6e18SStephane Eranian case AGGR_NONE: 74886ee6e18SStephane Eranian fprintf(output, "CPU%*d%s", 749d7470b6aSStephane Eranian csv_output ? 0 : -4, 75012c08a9fSStephane Eranian perf_evsel__cpus(evsel)->map[id], csv_sep); 75186ee6e18SStephane Eranian break; 75286ee6e18SStephane Eranian case AGGR_GLOBAL: 75386ee6e18SStephane Eranian default: 75486ee6e18SStephane Eranian break; 75586ee6e18SStephane Eranian } 75686ee6e18SStephane Eranian } 757d7470b6aSStephane Eranian 758da88c7f7SAndi Kleen static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg) 75986ee6e18SStephane Eranian { 76086ee6e18SStephane Eranian double msecs = avg / 1e6; 761410136f5SStephane Eranian const char *fmt_v, *fmt_n; 7624bbe5a61SDavid Ahern char name[25]; 76386ee6e18SStephane Eranian 764410136f5SStephane Eranian fmt_v = csv_output ? "%.6f%s" : "%18.6f%s"; 765410136f5SStephane Eranian fmt_n = csv_output ? "%s" : "%-25s"; 766410136f5SStephane Eranian 767da88c7f7SAndi Kleen aggr_printout(evsel, id, nr); 76886ee6e18SStephane Eranian 7694bbe5a61SDavid Ahern scnprintf(name, sizeof(name), "%s%s", 7704bbe5a61SDavid Ahern perf_evsel__name(evsel), csv_output ? "" : " (msec)"); 771410136f5SStephane Eranian 772410136f5SStephane Eranian fprintf(output, fmt_v, msecs, csv_sep); 773410136f5SStephane Eranian 774410136f5SStephane Eranian if (csv_output) 775410136f5SStephane Eranian fprintf(output, "%s%s", evsel->unit, csv_sep); 776410136f5SStephane Eranian else 777410136f5SStephane Eranian fprintf(output, "%-*s%s", unit_width, evsel->unit, csv_sep); 778410136f5SStephane Eranian 779410136f5SStephane Eranian fprintf(output, fmt_n, name); 780d7470b6aSStephane Eranian 781023695d9SStephane Eranian if (evsel->cgrp) 7824aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, evsel->cgrp->name); 783023695d9SStephane Eranian 78413370a9bSStephane Eranian if (csv_output || interval) 785d7470b6aSStephane Eranian return; 78642202dd5SIngo Molnar 787daec78a0SArnaldo Carvalho de Melo if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK)) 7884aa9015fSStephane Eranian fprintf(output, " # %8.3f CPUs utilized ", 7894aa9015fSStephane Eranian avg / avg_stats(&walltime_nsecs_stats)); 7909dac6a29SNamhyung Kim else 7919dac6a29SNamhyung Kim fprintf(output, " "); 79242202dd5SIngo Molnar } 79342202dd5SIngo Molnar 79415e6392fSNamhyung Kim /* used for get_ratio_color() */ 79515e6392fSNamhyung Kim enum grc_type { 79615e6392fSNamhyung Kim GRC_STALLED_CYCLES_FE, 79715e6392fSNamhyung Kim GRC_STALLED_CYCLES_BE, 79815e6392fSNamhyung Kim GRC_CACHE_MISSES, 79915e6392fSNamhyung Kim GRC_MAX_NR 80015e6392fSNamhyung Kim }; 80115e6392fSNamhyung Kim 80215e6392fSNamhyung Kim static const char *get_ratio_color(enum grc_type type, double ratio) 80315e6392fSNamhyung Kim { 80415e6392fSNamhyung Kim static const double grc_table[GRC_MAX_NR][3] = { 80515e6392fSNamhyung Kim [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 }, 80615e6392fSNamhyung Kim [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 }, 80715e6392fSNamhyung Kim [GRC_CACHE_MISSES] = { 20.0, 10.0, 5.0 }, 80815e6392fSNamhyung Kim }; 80915e6392fSNamhyung Kim const char *color = PERF_COLOR_NORMAL; 81015e6392fSNamhyung Kim 81115e6392fSNamhyung Kim if (ratio > grc_table[type][0]) 81215e6392fSNamhyung Kim color = PERF_COLOR_RED; 81315e6392fSNamhyung Kim else if (ratio > grc_table[type][1]) 81415e6392fSNamhyung Kim color = PERF_COLOR_MAGENTA; 81515e6392fSNamhyung Kim else if (ratio > grc_table[type][2]) 81615e6392fSNamhyung Kim color = PERF_COLOR_YELLOW; 81715e6392fSNamhyung Kim 81815e6392fSNamhyung Kim return color; 81915e6392fSNamhyung Kim } 82015e6392fSNamhyung Kim 8211d037ca1SIrina Tirdea static void print_stalled_cycles_frontend(int cpu, 8221d037ca1SIrina Tirdea struct perf_evsel *evsel 8231d037ca1SIrina Tirdea __maybe_unused, double avg) 824d3d1e86dSIngo Molnar { 825d3d1e86dSIngo Molnar double total, ratio = 0.0; 826d3d1e86dSIngo Molnar const char *color; 827d3d1e86dSIngo Molnar 828d3d1e86dSIngo Molnar total = avg_stats(&runtime_cycles_stats[cpu]); 829d3d1e86dSIngo Molnar 830d3d1e86dSIngo Molnar if (total) 831d3d1e86dSIngo Molnar ratio = avg / total * 100.0; 832d3d1e86dSIngo Molnar 83315e6392fSNamhyung Kim color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio); 834d3d1e86dSIngo Molnar 8354aa9015fSStephane Eranian fprintf(output, " # "); 8364aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 8374aa9015fSStephane Eranian fprintf(output, " frontend cycles idle "); 838d3d1e86dSIngo Molnar } 839d3d1e86dSIngo Molnar 8401d037ca1SIrina Tirdea static void print_stalled_cycles_backend(int cpu, 8411d037ca1SIrina Tirdea struct perf_evsel *evsel 8421d037ca1SIrina Tirdea __maybe_unused, double avg) 843a5d243d0SIngo Molnar { 844a5d243d0SIngo Molnar double total, ratio = 0.0; 845a5d243d0SIngo Molnar const char *color; 846a5d243d0SIngo Molnar 847a5d243d0SIngo Molnar total = avg_stats(&runtime_cycles_stats[cpu]); 848a5d243d0SIngo Molnar 849a5d243d0SIngo Molnar if (total) 850a5d243d0SIngo Molnar ratio = avg / total * 100.0; 851a5d243d0SIngo Molnar 85215e6392fSNamhyung Kim color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio); 853a5d243d0SIngo Molnar 8544aa9015fSStephane Eranian fprintf(output, " # "); 8554aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 8564aa9015fSStephane Eranian fprintf(output, " backend cycles idle "); 857a5d243d0SIngo Molnar } 858a5d243d0SIngo Molnar 8591d037ca1SIrina Tirdea static void print_branch_misses(int cpu, 8601d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 8611d037ca1SIrina Tirdea double avg) 862c78df6c1SIngo Molnar { 863c78df6c1SIngo Molnar double total, ratio = 0.0; 864c78df6c1SIngo Molnar const char *color; 865c78df6c1SIngo Molnar 866c78df6c1SIngo Molnar total = avg_stats(&runtime_branches_stats[cpu]); 867c78df6c1SIngo Molnar 868c78df6c1SIngo Molnar if (total) 869c78df6c1SIngo Molnar ratio = avg / total * 100.0; 870c78df6c1SIngo Molnar 87115e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 872c78df6c1SIngo Molnar 8734aa9015fSStephane Eranian fprintf(output, " # "); 8744aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 8754aa9015fSStephane Eranian fprintf(output, " of all branches "); 876c78df6c1SIngo Molnar } 877c78df6c1SIngo Molnar 8781d037ca1SIrina Tirdea static void print_l1_dcache_misses(int cpu, 8791d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 8801d037ca1SIrina Tirdea double avg) 8818bb6c79fSIngo Molnar { 8828bb6c79fSIngo Molnar double total, ratio = 0.0; 8838bb6c79fSIngo Molnar const char *color; 8848bb6c79fSIngo Molnar 8858bb6c79fSIngo Molnar total = avg_stats(&runtime_l1_dcache_stats[cpu]); 8868bb6c79fSIngo Molnar 8878bb6c79fSIngo Molnar if (total) 8888bb6c79fSIngo Molnar ratio = avg / total * 100.0; 8898bb6c79fSIngo Molnar 89015e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 8918bb6c79fSIngo Molnar 8924aa9015fSStephane Eranian fprintf(output, " # "); 8934aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 8944aa9015fSStephane Eranian fprintf(output, " of all L1-dcache hits "); 8958bb6c79fSIngo Molnar } 8968bb6c79fSIngo Molnar 8971d037ca1SIrina Tirdea static void print_l1_icache_misses(int cpu, 8981d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 8991d037ca1SIrina Tirdea double avg) 900c3305257SIngo Molnar { 901c3305257SIngo Molnar double total, ratio = 0.0; 902c3305257SIngo Molnar const char *color; 903c3305257SIngo Molnar 904c3305257SIngo Molnar total = avg_stats(&runtime_l1_icache_stats[cpu]); 905c3305257SIngo Molnar 906c3305257SIngo Molnar if (total) 907c3305257SIngo Molnar ratio = avg / total * 100.0; 908c3305257SIngo Molnar 90915e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 910c3305257SIngo Molnar 9114aa9015fSStephane Eranian fprintf(output, " # "); 9124aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9134aa9015fSStephane Eranian fprintf(output, " of all L1-icache hits "); 914c3305257SIngo Molnar } 915c3305257SIngo Molnar 9161d037ca1SIrina Tirdea static void print_dtlb_cache_misses(int cpu, 9171d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9181d037ca1SIrina Tirdea double avg) 919c3305257SIngo Molnar { 920c3305257SIngo Molnar double total, ratio = 0.0; 921c3305257SIngo Molnar const char *color; 922c3305257SIngo Molnar 923c3305257SIngo Molnar total = avg_stats(&runtime_dtlb_cache_stats[cpu]); 924c3305257SIngo Molnar 925c3305257SIngo Molnar if (total) 926c3305257SIngo Molnar ratio = avg / total * 100.0; 927c3305257SIngo Molnar 92815e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 929c3305257SIngo Molnar 9304aa9015fSStephane Eranian fprintf(output, " # "); 9314aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9324aa9015fSStephane Eranian fprintf(output, " of all dTLB cache hits "); 933c3305257SIngo Molnar } 934c3305257SIngo Molnar 9351d037ca1SIrina Tirdea static void print_itlb_cache_misses(int cpu, 9361d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9371d037ca1SIrina Tirdea double avg) 938c3305257SIngo Molnar { 939c3305257SIngo Molnar double total, ratio = 0.0; 940c3305257SIngo Molnar const char *color; 941c3305257SIngo Molnar 942c3305257SIngo Molnar total = avg_stats(&runtime_itlb_cache_stats[cpu]); 943c3305257SIngo Molnar 944c3305257SIngo Molnar if (total) 945c3305257SIngo Molnar ratio = avg / total * 100.0; 946c3305257SIngo Molnar 94715e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 948c3305257SIngo Molnar 9494aa9015fSStephane Eranian fprintf(output, " # "); 9504aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9514aa9015fSStephane Eranian fprintf(output, " of all iTLB cache hits "); 952c3305257SIngo Molnar } 953c3305257SIngo Molnar 9541d037ca1SIrina Tirdea static void print_ll_cache_misses(int cpu, 9551d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9561d037ca1SIrina Tirdea double avg) 957c3305257SIngo Molnar { 958c3305257SIngo Molnar double total, ratio = 0.0; 959c3305257SIngo Molnar const char *color; 960c3305257SIngo Molnar 961c3305257SIngo Molnar total = avg_stats(&runtime_ll_cache_stats[cpu]); 962c3305257SIngo Molnar 963c3305257SIngo Molnar if (total) 964c3305257SIngo Molnar ratio = avg / total * 100.0; 965c3305257SIngo Molnar 96615e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 967c3305257SIngo Molnar 9684aa9015fSStephane Eranian fprintf(output, " # "); 9694aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9704aa9015fSStephane Eranian fprintf(output, " of all LL-cache hits "); 971c3305257SIngo Molnar } 972c3305257SIngo Molnar 973da88c7f7SAndi Kleen static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg) 97442202dd5SIngo Molnar { 9754cabc3d1SAndi Kleen double total, ratio = 0.0, total2; 976410136f5SStephane Eranian double sc = evsel->scale; 977d7470b6aSStephane Eranian const char *fmt; 978da88c7f7SAndi Kleen int cpu = cpu_map__id_to_cpu(id); 979d7470b6aSStephane Eranian 980410136f5SStephane Eranian if (csv_output) { 981410136f5SStephane Eranian fmt = sc != 1.0 ? "%.2f%s" : "%.0f%s"; 982410136f5SStephane Eranian } else { 983410136f5SStephane Eranian if (big_num) 984410136f5SStephane Eranian fmt = sc != 1.0 ? "%'18.2f%s" : "%'18.0f%s"; 985d7470b6aSStephane Eranian else 986410136f5SStephane Eranian fmt = sc != 1.0 ? "%18.2f%s" : "%18.0f%s"; 987410136f5SStephane Eranian } 988f5b4a9c3SStephane Eranian 989da88c7f7SAndi Kleen aggr_printout(evsel, id, nr); 99086ee6e18SStephane Eranian 99186ee6e18SStephane Eranian if (aggr_mode == AGGR_GLOBAL) 992f5b4a9c3SStephane Eranian cpu = 0; 993c7f7fea3SIngo Molnar 994410136f5SStephane Eranian fprintf(output, fmt, avg, csv_sep); 995410136f5SStephane Eranian 996410136f5SStephane Eranian if (evsel->unit) 997410136f5SStephane Eranian fprintf(output, "%-*s%s", 998410136f5SStephane Eranian csv_output ? 0 : unit_width, 999410136f5SStephane Eranian evsel->unit, csv_sep); 1000410136f5SStephane Eranian 1001410136f5SStephane Eranian fprintf(output, "%-*s", csv_output ? 0 : 25, perf_evsel__name(evsel)); 1002d7470b6aSStephane Eranian 1003023695d9SStephane Eranian if (evsel->cgrp) 10044aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, evsel->cgrp->name); 1005023695d9SStephane Eranian 100613370a9bSStephane Eranian if (csv_output || interval) 1007d7470b6aSStephane Eranian return; 100842202dd5SIngo Molnar 1009daec78a0SArnaldo Carvalho de Melo if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) { 1010f5b4a9c3SStephane Eranian total = avg_stats(&runtime_cycles_stats[cpu]); 10113e7a0817SRamkumar Ramachandra if (total) { 1012c7f7fea3SIngo Molnar ratio = avg / total; 10134aa9015fSStephane Eranian fprintf(output, " # %5.2f insns per cycle ", ratio); 10143e7a0817SRamkumar Ramachandra } 1015d3d1e86dSIngo Molnar total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]); 1016d3d1e86dSIngo Molnar total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu])); 1017481f988aSIngo Molnar 1018481f988aSIngo Molnar if (total && avg) { 1019481f988aSIngo Molnar ratio = total / avg; 1020410136f5SStephane Eranian fprintf(output, "\n"); 1021410136f5SStephane Eranian if (aggr_mode == AGGR_NONE) 1022410136f5SStephane Eranian fprintf(output, " "); 1023410136f5SStephane Eranian fprintf(output, " # %5.2f stalled cycles per insn", ratio); 1024481f988aSIngo Molnar } 1025481f988aSIngo Molnar 1026daec78a0SArnaldo Carvalho de Melo } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) && 1027f5b4a9c3SStephane Eranian runtime_branches_stats[cpu].n != 0) { 1028c78df6c1SIngo Molnar print_branch_misses(cpu, evsel, avg); 10298bb6c79fSIngo Molnar } else if ( 10308bb6c79fSIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 10318bb6c79fSIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1D | 10328bb6c79fSIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 10338bb6c79fSIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1034c6264defSIngo Molnar runtime_l1_dcache_stats[cpu].n != 0) { 10358bb6c79fSIngo Molnar print_l1_dcache_misses(cpu, evsel, avg); 1036c3305257SIngo Molnar } else if ( 1037c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1038c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1I | 1039c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1040c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1041c3305257SIngo Molnar runtime_l1_icache_stats[cpu].n != 0) { 1042c3305257SIngo Molnar print_l1_icache_misses(cpu, evsel, avg); 1043c3305257SIngo Molnar } else if ( 1044c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1045c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_DTLB | 1046c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1047c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1048c3305257SIngo Molnar runtime_dtlb_cache_stats[cpu].n != 0) { 1049c3305257SIngo Molnar print_dtlb_cache_misses(cpu, evsel, avg); 1050c3305257SIngo Molnar } else if ( 1051c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1052c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_ITLB | 1053c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1054c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1055c3305257SIngo Molnar runtime_itlb_cache_stats[cpu].n != 0) { 1056c3305257SIngo Molnar print_itlb_cache_misses(cpu, evsel, avg); 1057c3305257SIngo Molnar } else if ( 1058c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1059c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_LL | 1060c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1061c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1062c3305257SIngo Molnar runtime_ll_cache_stats[cpu].n != 0) { 1063c3305257SIngo Molnar print_ll_cache_misses(cpu, evsel, avg); 1064d58f4c82SIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) && 1065d58f4c82SIngo Molnar runtime_cacherefs_stats[cpu].n != 0) { 1066d58f4c82SIngo Molnar total = avg_stats(&runtime_cacherefs_stats[cpu]); 1067d58f4c82SIngo Molnar 1068d58f4c82SIngo Molnar if (total) 1069d58f4c82SIngo Molnar ratio = avg * 100 / total; 1070d58f4c82SIngo Molnar 10714aa9015fSStephane Eranian fprintf(output, " # %8.3f %% of all cache refs ", ratio); 1072d58f4c82SIngo Molnar 1073d3d1e86dSIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) { 1074d3d1e86dSIngo Molnar print_stalled_cycles_frontend(cpu, evsel, avg); 1075129c04cbSIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) { 1076d3d1e86dSIngo Molnar print_stalled_cycles_backend(cpu, evsel, avg); 1077481f988aSIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) { 1078481f988aSIngo Molnar total = avg_stats(&runtime_nsecs_stats[cpu]); 1079481f988aSIngo Molnar 1080c458fe62SRamkumar Ramachandra if (total) { 1081c458fe62SRamkumar Ramachandra ratio = avg / total; 10824aa9015fSStephane Eranian fprintf(output, " # %8.3f GHz ", ratio); 1083c458fe62SRamkumar Ramachandra } 10844cabc3d1SAndi Kleen } else if (transaction_run && 10854cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX))) { 10864cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_stats[cpu]); 10874cabc3d1SAndi Kleen if (total) 10884cabc3d1SAndi Kleen fprintf(output, 10894cabc3d1SAndi Kleen " # %5.2f%% transactional cycles ", 10904cabc3d1SAndi Kleen 100.0 * (avg / total)); 10914cabc3d1SAndi Kleen } else if (transaction_run && 10924cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX_CP))) { 10934cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_stats[cpu]); 10944cabc3d1SAndi Kleen total2 = avg_stats(&runtime_cycles_in_tx_stats[cpu]); 10954cabc3d1SAndi Kleen if (total2 < avg) 10964cabc3d1SAndi Kleen total2 = avg; 10974cabc3d1SAndi Kleen if (total) 10984cabc3d1SAndi Kleen fprintf(output, 10994cabc3d1SAndi Kleen " # %5.2f%% aborted cycles ", 11004cabc3d1SAndi Kleen 100.0 * ((total2-avg) / total)); 11014cabc3d1SAndi Kleen } else if (transaction_run && 11024cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_TRANSACTION_START)) && 11034cabc3d1SAndi Kleen avg > 0 && 11044cabc3d1SAndi Kleen runtime_cycles_in_tx_stats[cpu].n != 0) { 11054cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_in_tx_stats[cpu]); 11064cabc3d1SAndi Kleen 11074cabc3d1SAndi Kleen if (total) 11084cabc3d1SAndi Kleen ratio = total / avg; 11094cabc3d1SAndi Kleen 11104cabc3d1SAndi Kleen fprintf(output, " # %8.0f cycles / transaction ", ratio); 11114cabc3d1SAndi Kleen } else if (transaction_run && 11124cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_ELISION_START)) && 11134cabc3d1SAndi Kleen avg > 0 && 11144cabc3d1SAndi Kleen runtime_cycles_in_tx_stats[cpu].n != 0) { 11154cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_in_tx_stats[cpu]); 11164cabc3d1SAndi Kleen 11174cabc3d1SAndi Kleen if (total) 11184cabc3d1SAndi Kleen ratio = total / avg; 11194cabc3d1SAndi Kleen 11204cabc3d1SAndi Kleen fprintf(output, " # %8.0f cycles / elision ", ratio); 1121481f988aSIngo Molnar } else if (runtime_nsecs_stats[cpu].n != 0) { 11225fde2523SNamhyung Kim char unit = 'M'; 11235fde2523SNamhyung Kim 1124481f988aSIngo Molnar total = avg_stats(&runtime_nsecs_stats[cpu]); 1125481f988aSIngo Molnar 1126481f988aSIngo Molnar if (total) 1127481f988aSIngo Molnar ratio = 1000.0 * avg / total; 11285fde2523SNamhyung Kim if (ratio < 0.001) { 11295fde2523SNamhyung Kim ratio *= 1000; 11305fde2523SNamhyung Kim unit = 'K'; 11315fde2523SNamhyung Kim } 1132481f988aSIngo Molnar 11335fde2523SNamhyung Kim fprintf(output, " # %8.3f %c/sec ", ratio, unit); 1134a5d243d0SIngo Molnar } else { 11354aa9015fSStephane Eranian fprintf(output, " "); 113642202dd5SIngo Molnar } 113742202dd5SIngo Molnar } 113842202dd5SIngo Molnar 113986ee6e18SStephane Eranian static void print_aggr(char *prefix) 1140d7e7a451SStephane Eranian { 1141d7e7a451SStephane Eranian struct perf_evsel *counter; 1142582ec082SStephane Eranian int cpu, cpu2, s, s2, id, nr; 1143410136f5SStephane Eranian double uval; 1144d7e7a451SStephane Eranian u64 ena, run, val; 1145d7e7a451SStephane Eranian 114686ee6e18SStephane Eranian if (!(aggr_map || aggr_get_id)) 1147d7e7a451SStephane Eranian return; 1148d7e7a451SStephane Eranian 114986ee6e18SStephane Eranian for (s = 0; s < aggr_map->nr; s++) { 115086ee6e18SStephane Eranian id = aggr_map->map[s]; 11510050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 1152d7e7a451SStephane Eranian val = ena = run = 0; 1153d7e7a451SStephane Eranian nr = 0; 1154d7e7a451SStephane Eranian for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1155582ec082SStephane Eranian cpu2 = perf_evsel__cpus(counter)->map[cpu]; 1156582ec082SStephane Eranian s2 = aggr_get_id(evsel_list->cpus, cpu2); 115786ee6e18SStephane Eranian if (s2 != id) 1158d7e7a451SStephane Eranian continue; 1159d7e7a451SStephane Eranian val += counter->counts->cpu[cpu].val; 1160d7e7a451SStephane Eranian ena += counter->counts->cpu[cpu].ena; 1161d7e7a451SStephane Eranian run += counter->counts->cpu[cpu].run; 1162d7e7a451SStephane Eranian nr++; 1163d7e7a451SStephane Eranian } 1164d7e7a451SStephane Eranian if (prefix) 1165d7e7a451SStephane Eranian fprintf(output, "%s", prefix); 1166d7e7a451SStephane Eranian 1167d7e7a451SStephane Eranian if (run == 0 || ena == 0) { 1168582ec082SStephane Eranian aggr_printout(counter, id, nr); 116986ee6e18SStephane Eranian 1170410136f5SStephane Eranian fprintf(output, "%*s%s", 1171d7e7a451SStephane Eranian csv_output ? 0 : 18, 1172d7e7a451SStephane Eranian counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1173410136f5SStephane Eranian csv_sep); 1174410136f5SStephane Eranian 1175410136f5SStephane Eranian fprintf(output, "%-*s%s", 1176410136f5SStephane Eranian csv_output ? 0 : unit_width, 1177410136f5SStephane Eranian counter->unit, csv_sep); 1178410136f5SStephane Eranian 1179410136f5SStephane Eranian fprintf(output, "%*s", 1180410136f5SStephane Eranian csv_output ? 0 : -25, 1181d7e7a451SStephane Eranian perf_evsel__name(counter)); 118286ee6e18SStephane Eranian 1183d7e7a451SStephane Eranian if (counter->cgrp) 1184d7e7a451SStephane Eranian fprintf(output, "%s%s", 1185d7e7a451SStephane Eranian csv_sep, counter->cgrp->name); 1186d7e7a451SStephane Eranian 1187d7e7a451SStephane Eranian fputc('\n', output); 1188d7e7a451SStephane Eranian continue; 1189d7e7a451SStephane Eranian } 1190410136f5SStephane Eranian uval = val * counter->scale; 1191d7e7a451SStephane Eranian 1192d7e7a451SStephane Eranian if (nsec_counter(counter)) 1193410136f5SStephane Eranian nsec_printout(id, nr, counter, uval); 1194d7e7a451SStephane Eranian else 1195410136f5SStephane Eranian abs_printout(id, nr, counter, uval); 1196d7e7a451SStephane Eranian 1197d7e7a451SStephane Eranian if (!csv_output) { 1198d7e7a451SStephane Eranian print_noise(counter, 1.0); 1199d7e7a451SStephane Eranian 1200d7e7a451SStephane Eranian if (run != ena) 1201d7e7a451SStephane Eranian fprintf(output, " (%.2f%%)", 1202d7e7a451SStephane Eranian 100.0 * run / ena); 1203d7e7a451SStephane Eranian } 1204d7e7a451SStephane Eranian fputc('\n', output); 1205d7e7a451SStephane Eranian } 1206d7e7a451SStephane Eranian } 1207d7e7a451SStephane Eranian } 1208d7e7a451SStephane Eranian 120942202dd5SIngo Molnar /* 121042202dd5SIngo Molnar * Print out the results of a single counter: 1211f5b4a9c3SStephane Eranian * aggregated counts in system-wide mode 121242202dd5SIngo Molnar */ 121313370a9bSStephane Eranian static void print_counter_aggr(struct perf_evsel *counter, char *prefix) 121442202dd5SIngo Molnar { 121569aad6f1SArnaldo Carvalho de Melo struct perf_stat *ps = counter->priv; 121669aad6f1SArnaldo Carvalho de Melo double avg = avg_stats(&ps->res_stats[0]); 1217c52b12edSArnaldo Carvalho de Melo int scaled = counter->counts->scaled; 1218410136f5SStephane Eranian double uval; 121942202dd5SIngo Molnar 122013370a9bSStephane Eranian if (prefix) 122113370a9bSStephane Eranian fprintf(output, "%s", prefix); 122213370a9bSStephane Eranian 122342202dd5SIngo Molnar if (scaled == -1) { 1224410136f5SStephane Eranian fprintf(output, "%*s%s", 1225d7470b6aSStephane Eranian csv_output ? 0 : 18, 12262cee77c4SDavid Ahern counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1227410136f5SStephane Eranian csv_sep); 1228410136f5SStephane Eranian fprintf(output, "%-*s%s", 1229410136f5SStephane Eranian csv_output ? 0 : unit_width, 1230410136f5SStephane Eranian counter->unit, csv_sep); 1231410136f5SStephane Eranian fprintf(output, "%*s", 1232410136f5SStephane Eranian csv_output ? 0 : -25, 12337289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 1234023695d9SStephane Eranian 1235023695d9SStephane Eranian if (counter->cgrp) 12364aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, counter->cgrp->name); 1237023695d9SStephane Eranian 12384aa9015fSStephane Eranian fputc('\n', output); 123942202dd5SIngo Molnar return; 124042202dd5SIngo Molnar } 124142202dd5SIngo Molnar 1242410136f5SStephane Eranian uval = avg * counter->scale; 1243410136f5SStephane Eranian 124442202dd5SIngo Molnar if (nsec_counter(counter)) 1245410136f5SStephane Eranian nsec_printout(-1, 0, counter, uval); 124642202dd5SIngo Molnar else 1247410136f5SStephane Eranian abs_printout(-1, 0, counter, uval); 1248849abde9SPeter Zijlstra 12493ae9a34dSZhengyu He print_noise(counter, avg); 12503ae9a34dSZhengyu He 1251d7470b6aSStephane Eranian if (csv_output) { 12524aa9015fSStephane Eranian fputc('\n', output); 1253d7470b6aSStephane Eranian return; 1254d7470b6aSStephane Eranian } 1255d7470b6aSStephane Eranian 1256506d4bc8SPeter Zijlstra if (scaled) { 1257506d4bc8SPeter Zijlstra double avg_enabled, avg_running; 1258506d4bc8SPeter Zijlstra 125969aad6f1SArnaldo Carvalho de Melo avg_enabled = avg_stats(&ps->res_stats[1]); 126069aad6f1SArnaldo Carvalho de Melo avg_running = avg_stats(&ps->res_stats[2]); 1261506d4bc8SPeter Zijlstra 12624aa9015fSStephane Eranian fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled); 1263506d4bc8SPeter Zijlstra } 12644aa9015fSStephane Eranian fprintf(output, "\n"); 126542202dd5SIngo Molnar } 126642202dd5SIngo Molnar 1267f5b4a9c3SStephane Eranian /* 1268f5b4a9c3SStephane Eranian * Print out the results of a single counter: 1269f5b4a9c3SStephane Eranian * does not use aggregated count in system-wide 1270f5b4a9c3SStephane Eranian */ 127113370a9bSStephane Eranian static void print_counter(struct perf_evsel *counter, char *prefix) 1272f5b4a9c3SStephane Eranian { 1273f5b4a9c3SStephane Eranian u64 ena, run, val; 1274410136f5SStephane Eranian double uval; 1275f5b4a9c3SStephane Eranian int cpu; 1276f5b4a9c3SStephane Eranian 12777ae92e74SYan, Zheng for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1278c52b12edSArnaldo Carvalho de Melo val = counter->counts->cpu[cpu].val; 1279c52b12edSArnaldo Carvalho de Melo ena = counter->counts->cpu[cpu].ena; 1280c52b12edSArnaldo Carvalho de Melo run = counter->counts->cpu[cpu].run; 128113370a9bSStephane Eranian 128213370a9bSStephane Eranian if (prefix) 128313370a9bSStephane Eranian fprintf(output, "%s", prefix); 128413370a9bSStephane Eranian 1285f5b4a9c3SStephane Eranian if (run == 0 || ena == 0) { 1286410136f5SStephane Eranian fprintf(output, "CPU%*d%s%*s%s", 1287d7470b6aSStephane Eranian csv_output ? 0 : -4, 12887ae92e74SYan, Zheng perf_evsel__cpus(counter)->map[cpu], csv_sep, 1289d7470b6aSStephane Eranian csv_output ? 0 : 18, 12902cee77c4SDavid Ahern counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1291410136f5SStephane Eranian csv_sep); 1292410136f5SStephane Eranian 1293410136f5SStephane Eranian fprintf(output, "%-*s%s", 1294410136f5SStephane Eranian csv_output ? 0 : unit_width, 1295410136f5SStephane Eranian counter->unit, csv_sep); 1296410136f5SStephane Eranian 1297410136f5SStephane Eranian fprintf(output, "%*s", 1298410136f5SStephane Eranian csv_output ? 0 : -25, 12997289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 1300f5b4a9c3SStephane Eranian 1301023695d9SStephane Eranian if (counter->cgrp) 13024aa9015fSStephane Eranian fprintf(output, "%s%s", 13034aa9015fSStephane Eranian csv_sep, counter->cgrp->name); 1304023695d9SStephane Eranian 13054aa9015fSStephane Eranian fputc('\n', output); 1306f5b4a9c3SStephane Eranian continue; 1307f5b4a9c3SStephane Eranian } 1308f5b4a9c3SStephane Eranian 1309410136f5SStephane Eranian uval = val * counter->scale; 1310410136f5SStephane Eranian 1311f5b4a9c3SStephane Eranian if (nsec_counter(counter)) 1312410136f5SStephane Eranian nsec_printout(cpu, 0, counter, uval); 1313f5b4a9c3SStephane Eranian else 1314410136f5SStephane Eranian abs_printout(cpu, 0, counter, uval); 1315f5b4a9c3SStephane Eranian 1316d7470b6aSStephane Eranian if (!csv_output) { 1317f5b4a9c3SStephane Eranian print_noise(counter, 1.0); 1318f5b4a9c3SStephane Eranian 1319c6264defSIngo Molnar if (run != ena) 13204aa9015fSStephane Eranian fprintf(output, " (%.2f%%)", 13214aa9015fSStephane Eranian 100.0 * run / ena); 1322d7470b6aSStephane Eranian } 13234aa9015fSStephane Eranian fputc('\n', output); 1324f5b4a9c3SStephane Eranian } 1325f5b4a9c3SStephane Eranian } 1326f5b4a9c3SStephane Eranian 132742202dd5SIngo Molnar static void print_stat(int argc, const char **argv) 132842202dd5SIngo Molnar { 132969aad6f1SArnaldo Carvalho de Melo struct perf_evsel *counter; 133069aad6f1SArnaldo Carvalho de Melo int i; 133142202dd5SIngo Molnar 133286470930SIngo Molnar fflush(stdout); 133386470930SIngo Molnar 1334d7470b6aSStephane Eranian if (!csv_output) { 13354aa9015fSStephane Eranian fprintf(output, "\n"); 13364aa9015fSStephane Eranian fprintf(output, " Performance counter stats for "); 133762d3b617SDavid Ahern if (target.system_wide) 133862d3b617SDavid Ahern fprintf(output, "\'system wide"); 133962d3b617SDavid Ahern else if (target.cpu_list) 134062d3b617SDavid Ahern fprintf(output, "\'CPU(s) %s", target.cpu_list); 1341602ad878SArnaldo Carvalho de Melo else if (!target__has_task(&target)) { 13424aa9015fSStephane Eranian fprintf(output, "\'%s", argv[0]); 134386470930SIngo Molnar for (i = 1; i < argc; i++) 13444aa9015fSStephane Eranian fprintf(output, " %s", argv[i]); 134520f946b4SNamhyung Kim } else if (target.pid) 134620f946b4SNamhyung Kim fprintf(output, "process id \'%s", target.pid); 1347d6d901c2SZhang, Yanmin else 134820f946b4SNamhyung Kim fprintf(output, "thread id \'%s", target.tid); 134986470930SIngo Molnar 13504aa9015fSStephane Eranian fprintf(output, "\'"); 135142202dd5SIngo Molnar if (run_count > 1) 13524aa9015fSStephane Eranian fprintf(output, " (%d runs)", run_count); 13534aa9015fSStephane Eranian fprintf(output, ":\n\n"); 1354d7470b6aSStephane Eranian } 135586470930SIngo Molnar 135686ee6e18SStephane Eranian switch (aggr_mode) { 135712c08a9fSStephane Eranian case AGGR_CORE: 135886ee6e18SStephane Eranian case AGGR_SOCKET: 135986ee6e18SStephane Eranian print_aggr(NULL); 136086ee6e18SStephane Eranian break; 136186ee6e18SStephane Eranian case AGGR_GLOBAL: 13620050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 136313370a9bSStephane Eranian print_counter_aggr(counter, NULL); 136486ee6e18SStephane Eranian break; 136586ee6e18SStephane Eranian case AGGR_NONE: 13660050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 136786ee6e18SStephane Eranian print_counter(counter, NULL); 136886ee6e18SStephane Eranian break; 136986ee6e18SStephane Eranian default: 137086ee6e18SStephane Eranian break; 1371f5b4a9c3SStephane Eranian } 137286470930SIngo Molnar 1373d7470b6aSStephane Eranian if (!csv_output) { 1374c3305257SIngo Molnar if (!null_run) 13754aa9015fSStephane Eranian fprintf(output, "\n"); 13764aa9015fSStephane Eranian fprintf(output, " %17.9f seconds time elapsed", 1377506d4bc8SPeter Zijlstra avg_stats(&walltime_nsecs_stats)/1e9); 1378566747e6SIngo Molnar if (run_count > 1) { 13794aa9015fSStephane Eranian fprintf(output, " "); 1380f99844cbSIngo Molnar print_noise_pct(stddev_stats(&walltime_nsecs_stats), 1381506d4bc8SPeter Zijlstra avg_stats(&walltime_nsecs_stats)); 1382566747e6SIngo Molnar } 13834aa9015fSStephane Eranian fprintf(output, "\n\n"); 138486470930SIngo Molnar } 1385d7470b6aSStephane Eranian } 138686470930SIngo Molnar 1387f7b7c26eSPeter Zijlstra static volatile int signr = -1; 1388f7b7c26eSPeter Zijlstra 138986470930SIngo Molnar static void skip_signal(int signo) 139086470930SIngo Molnar { 139113370a9bSStephane Eranian if ((child_pid == -1) || interval) 139260666c63SLiming Wang done = 1; 139360666c63SLiming Wang 1394f7b7c26eSPeter Zijlstra signr = signo; 1395d07f0b12SStephane Eranian /* 1396d07f0b12SStephane Eranian * render child_pid harmless 1397d07f0b12SStephane Eranian * won't send SIGTERM to a random 1398d07f0b12SStephane Eranian * process in case of race condition 1399d07f0b12SStephane Eranian * and fast PID recycling 1400d07f0b12SStephane Eranian */ 1401d07f0b12SStephane Eranian child_pid = -1; 1402f7b7c26eSPeter Zijlstra } 1403f7b7c26eSPeter Zijlstra 1404f7b7c26eSPeter Zijlstra static void sig_atexit(void) 1405f7b7c26eSPeter Zijlstra { 1406d07f0b12SStephane Eranian sigset_t set, oset; 1407d07f0b12SStephane Eranian 1408d07f0b12SStephane Eranian /* 1409d07f0b12SStephane Eranian * avoid race condition with SIGCHLD handler 1410d07f0b12SStephane Eranian * in skip_signal() which is modifying child_pid 1411d07f0b12SStephane Eranian * goal is to avoid send SIGTERM to a random 1412d07f0b12SStephane Eranian * process 1413d07f0b12SStephane Eranian */ 1414d07f0b12SStephane Eranian sigemptyset(&set); 1415d07f0b12SStephane Eranian sigaddset(&set, SIGCHLD); 1416d07f0b12SStephane Eranian sigprocmask(SIG_BLOCK, &set, &oset); 1417d07f0b12SStephane Eranian 1418933da83aSChris Wilson if (child_pid != -1) 1419933da83aSChris Wilson kill(child_pid, SIGTERM); 1420933da83aSChris Wilson 1421d07f0b12SStephane Eranian sigprocmask(SIG_SETMASK, &oset, NULL); 1422d07f0b12SStephane Eranian 1423f7b7c26eSPeter Zijlstra if (signr == -1) 1424f7b7c26eSPeter Zijlstra return; 1425f7b7c26eSPeter Zijlstra 1426f7b7c26eSPeter Zijlstra signal(signr, SIG_DFL); 1427f7b7c26eSPeter Zijlstra kill(getpid(), signr); 142886470930SIngo Molnar } 142986470930SIngo Molnar 14301d037ca1SIrina Tirdea static int stat__set_big_num(const struct option *opt __maybe_unused, 14311d037ca1SIrina Tirdea const char *s __maybe_unused, int unset) 1432d7470b6aSStephane Eranian { 1433d7470b6aSStephane Eranian big_num_opt = unset ? 0 : 1; 1434d7470b6aSStephane Eranian return 0; 1435d7470b6aSStephane Eranian } 1436d7470b6aSStephane Eranian 143786ee6e18SStephane Eranian static int perf_stat_init_aggr_mode(void) 143886ee6e18SStephane Eranian { 143986ee6e18SStephane Eranian switch (aggr_mode) { 144086ee6e18SStephane Eranian case AGGR_SOCKET: 144186ee6e18SStephane Eranian if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) { 144286ee6e18SStephane Eranian perror("cannot build socket map"); 144386ee6e18SStephane Eranian return -1; 144486ee6e18SStephane Eranian } 144586ee6e18SStephane Eranian aggr_get_id = cpu_map__get_socket; 144686ee6e18SStephane Eranian break; 144712c08a9fSStephane Eranian case AGGR_CORE: 144812c08a9fSStephane Eranian if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) { 144912c08a9fSStephane Eranian perror("cannot build core map"); 145012c08a9fSStephane Eranian return -1; 145112c08a9fSStephane Eranian } 145212c08a9fSStephane Eranian aggr_get_id = cpu_map__get_core; 145312c08a9fSStephane Eranian break; 145486ee6e18SStephane Eranian case AGGR_NONE: 145586ee6e18SStephane Eranian case AGGR_GLOBAL: 145686ee6e18SStephane Eranian default: 145786ee6e18SStephane Eranian break; 145886ee6e18SStephane Eranian } 145986ee6e18SStephane Eranian return 0; 146086ee6e18SStephane Eranian } 146186ee6e18SStephane Eranian 14624cabc3d1SAndi Kleen static int setup_events(const char * const *attrs, unsigned len) 14634cabc3d1SAndi Kleen { 14644cabc3d1SAndi Kleen unsigned i; 14654cabc3d1SAndi Kleen 14664cabc3d1SAndi Kleen for (i = 0; i < len; i++) { 14674cabc3d1SAndi Kleen if (parse_events(evsel_list, attrs[i])) 14684cabc3d1SAndi Kleen return -1; 14694cabc3d1SAndi Kleen } 14704cabc3d1SAndi Kleen return 0; 14714cabc3d1SAndi Kleen } 147286ee6e18SStephane Eranian 14732cba3ffbSIngo Molnar /* 14742cba3ffbSIngo Molnar * Add default attributes, if there were no attributes specified or 14752cba3ffbSIngo Molnar * if -d/--detailed, -d -d or -d -d -d is used: 14762cba3ffbSIngo Molnar */ 14772cba3ffbSIngo Molnar static int add_default_attributes(void) 14782cba3ffbSIngo Molnar { 1479b070a547SArnaldo Carvalho de Melo struct perf_event_attr default_attrs[] = { 1480b070a547SArnaldo Carvalho de Melo 1481b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK }, 1482b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES }, 1483b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS }, 1484b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS }, 1485b070a547SArnaldo Carvalho de Melo 1486b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES }, 1487b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND }, 1488b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND }, 1489b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS }, 1490b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS }, 1491b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES }, 1492b070a547SArnaldo Carvalho de Melo 1493b070a547SArnaldo Carvalho de Melo }; 1494b070a547SArnaldo Carvalho de Melo 1495b070a547SArnaldo Carvalho de Melo /* 1496b070a547SArnaldo Carvalho de Melo * Detailed stats (-d), covering the L1 and last level data caches: 1497b070a547SArnaldo Carvalho de Melo */ 1498b070a547SArnaldo Carvalho de Melo struct perf_event_attr detailed_attrs[] = { 1499b070a547SArnaldo Carvalho de Melo 1500b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1501b070a547SArnaldo Carvalho de Melo .config = 1502b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1503b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1504b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1505b070a547SArnaldo Carvalho de Melo 1506b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1507b070a547SArnaldo Carvalho de Melo .config = 1508b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1509b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1510b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1511b070a547SArnaldo Carvalho de Melo 1512b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1513b070a547SArnaldo Carvalho de Melo .config = 1514b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 1515b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1516b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1517b070a547SArnaldo Carvalho de Melo 1518b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1519b070a547SArnaldo Carvalho de Melo .config = 1520b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 1521b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1522b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1523b070a547SArnaldo Carvalho de Melo }; 1524b070a547SArnaldo Carvalho de Melo 1525b070a547SArnaldo Carvalho de Melo /* 1526b070a547SArnaldo Carvalho de Melo * Very detailed stats (-d -d), covering the instruction cache and the TLB caches: 1527b070a547SArnaldo Carvalho de Melo */ 1528b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_detailed_attrs[] = { 1529b070a547SArnaldo Carvalho de Melo 1530b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1531b070a547SArnaldo Carvalho de Melo .config = 1532b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 1533b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1534b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1535b070a547SArnaldo Carvalho de Melo 1536b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1537b070a547SArnaldo Carvalho de Melo .config = 1538b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 1539b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1540b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1541b070a547SArnaldo Carvalho de Melo 1542b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1543b070a547SArnaldo Carvalho de Melo .config = 1544b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 1545b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1546b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1547b070a547SArnaldo Carvalho de Melo 1548b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1549b070a547SArnaldo Carvalho de Melo .config = 1550b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 1551b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1552b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1553b070a547SArnaldo Carvalho de Melo 1554b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1555b070a547SArnaldo Carvalho de Melo .config = 1556b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 1557b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1558b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1559b070a547SArnaldo Carvalho de Melo 1560b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1561b070a547SArnaldo Carvalho de Melo .config = 1562b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 1563b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1564b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1565b070a547SArnaldo Carvalho de Melo 1566b070a547SArnaldo Carvalho de Melo }; 1567b070a547SArnaldo Carvalho de Melo 1568b070a547SArnaldo Carvalho de Melo /* 1569b070a547SArnaldo Carvalho de Melo * Very, very detailed stats (-d -d -d), adding prefetch events: 1570b070a547SArnaldo Carvalho de Melo */ 1571b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_very_detailed_attrs[] = { 1572b070a547SArnaldo Carvalho de Melo 1573b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1574b070a547SArnaldo Carvalho de Melo .config = 1575b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1576b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 1577b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1578b070a547SArnaldo Carvalho de Melo 1579b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1580b070a547SArnaldo Carvalho de Melo .config = 1581b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1582b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 1583b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1584b070a547SArnaldo Carvalho de Melo }; 1585b070a547SArnaldo Carvalho de Melo 15862cba3ffbSIngo Molnar /* Set attrs if no event is selected and !null_run: */ 15872cba3ffbSIngo Molnar if (null_run) 15882cba3ffbSIngo Molnar return 0; 15892cba3ffbSIngo Molnar 15904cabc3d1SAndi Kleen if (transaction_run) { 15914cabc3d1SAndi Kleen int err; 15924cabc3d1SAndi Kleen if (pmu_have_event("cpu", "cycles-ct") && 15934cabc3d1SAndi Kleen pmu_have_event("cpu", "el-start")) 15944cabc3d1SAndi Kleen err = setup_events(transaction_attrs, 15954cabc3d1SAndi Kleen ARRAY_SIZE(transaction_attrs)); 15964cabc3d1SAndi Kleen else 15974cabc3d1SAndi Kleen err = setup_events(transaction_limited_attrs, 15984cabc3d1SAndi Kleen ARRAY_SIZE(transaction_limited_attrs)); 15994cabc3d1SAndi Kleen if (err < 0) { 16004cabc3d1SAndi Kleen fprintf(stderr, "Cannot set up transaction events\n"); 16014cabc3d1SAndi Kleen return -1; 16024cabc3d1SAndi Kleen } 16034cabc3d1SAndi Kleen return 0; 16044cabc3d1SAndi Kleen } 16054cabc3d1SAndi Kleen 16062cba3ffbSIngo Molnar if (!evsel_list->nr_entries) { 160779695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, default_attrs) < 0) 16082cba3ffbSIngo Molnar return -1; 16092cba3ffbSIngo Molnar } 16102cba3ffbSIngo Molnar 16112cba3ffbSIngo Molnar /* Detailed events get appended to the event list: */ 16122cba3ffbSIngo Molnar 16132cba3ffbSIngo Molnar if (detailed_run < 1) 16142cba3ffbSIngo Molnar return 0; 16152cba3ffbSIngo Molnar 16162cba3ffbSIngo Molnar /* Append detailed run extra attributes: */ 161779695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0) 16182cba3ffbSIngo Molnar return -1; 16192cba3ffbSIngo Molnar 16202cba3ffbSIngo Molnar if (detailed_run < 2) 16212cba3ffbSIngo Molnar return 0; 16222cba3ffbSIngo Molnar 16232cba3ffbSIngo Molnar /* Append very detailed run extra attributes: */ 162479695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0) 16252cba3ffbSIngo Molnar return -1; 16262cba3ffbSIngo Molnar 16272cba3ffbSIngo Molnar if (detailed_run < 3) 16282cba3ffbSIngo Molnar return 0; 16292cba3ffbSIngo Molnar 16302cba3ffbSIngo Molnar /* Append very, very detailed run extra attributes: */ 163179695e1bSArnaldo Carvalho de Melo return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs); 16322cba3ffbSIngo Molnar } 16332cba3ffbSIngo Molnar 16341d037ca1SIrina Tirdea int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused) 163586470930SIngo Molnar { 16361f16c575SPeter Zijlstra bool append_file = false; 1637b070a547SArnaldo Carvalho de Melo int output_fd = 0; 1638b070a547SArnaldo Carvalho de Melo const char *output_name = NULL; 1639b070a547SArnaldo Carvalho de Melo const struct option options[] = { 16404cabc3d1SAndi Kleen OPT_BOOLEAN('T', "transaction", &transaction_run, 16414cabc3d1SAndi Kleen "hardware transaction statistics"), 1642b070a547SArnaldo Carvalho de Melo OPT_CALLBACK('e', "event", &evsel_list, "event", 1643b070a547SArnaldo Carvalho de Melo "event selector. use 'perf list' to list available events", 1644b070a547SArnaldo Carvalho de Melo parse_events_option), 1645b070a547SArnaldo Carvalho de Melo OPT_CALLBACK(0, "filter", &evsel_list, "filter", 1646b070a547SArnaldo Carvalho de Melo "event filter", parse_filter), 1647b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('i', "no-inherit", &no_inherit, 1648b070a547SArnaldo Carvalho de Melo "child tasks do not inherit counters"), 1649b070a547SArnaldo Carvalho de Melo OPT_STRING('p', "pid", &target.pid, "pid", 1650b070a547SArnaldo Carvalho de Melo "stat events on existing process id"), 1651b070a547SArnaldo Carvalho de Melo OPT_STRING('t', "tid", &target.tid, "tid", 1652b070a547SArnaldo Carvalho de Melo "stat events on existing thread id"), 1653b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('a', "all-cpus", &target.system_wide, 1654b070a547SArnaldo Carvalho de Melo "system-wide collection from all CPUs"), 1655b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('g', "group", &group, 1656b070a547SArnaldo Carvalho de Melo "put the counters into a counter group"), 1657b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('c', "scale", &scale, "scale/normalize counters"), 1658b070a547SArnaldo Carvalho de Melo OPT_INCR('v', "verbose", &verbose, 1659b070a547SArnaldo Carvalho de Melo "be more verbose (show counter open errors, etc)"), 1660b070a547SArnaldo Carvalho de Melo OPT_INTEGER('r', "repeat", &run_count, 1661a7e191c3SFrederik Deweerdt "repeat command and print average + stddev (max: 100, forever: 0)"), 1662b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('n', "null", &null_run, 1663b070a547SArnaldo Carvalho de Melo "null run - dont start any counters"), 1664b070a547SArnaldo Carvalho de Melo OPT_INCR('d', "detailed", &detailed_run, 1665b070a547SArnaldo Carvalho de Melo "detailed run - start a lot of events"), 1666b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('S', "sync", &sync_run, 1667b070a547SArnaldo Carvalho de Melo "call sync() before starting a run"), 1668b070a547SArnaldo Carvalho de Melo OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 1669b070a547SArnaldo Carvalho de Melo "print large numbers with thousands\' separators", 1670b070a547SArnaldo Carvalho de Melo stat__set_big_num), 1671b070a547SArnaldo Carvalho de Melo OPT_STRING('C', "cpu", &target.cpu_list, "cpu", 1672b070a547SArnaldo Carvalho de Melo "list of cpus to monitor in system-wide"), 167386ee6e18SStephane Eranian OPT_SET_UINT('A', "no-aggr", &aggr_mode, 167486ee6e18SStephane Eranian "disable CPU count aggregation", AGGR_NONE), 1675b070a547SArnaldo Carvalho de Melo OPT_STRING('x', "field-separator", &csv_sep, "separator", 1676b070a547SArnaldo Carvalho de Melo "print counts with custom separator"), 1677b070a547SArnaldo Carvalho de Melo OPT_CALLBACK('G', "cgroup", &evsel_list, "name", 1678b070a547SArnaldo Carvalho de Melo "monitor event in cgroup name only", parse_cgroups), 1679b070a547SArnaldo Carvalho de Melo OPT_STRING('o', "output", &output_name, "file", "output file name"), 1680b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN(0, "append", &append_file, "append to the output file"), 1681b070a547SArnaldo Carvalho de Melo OPT_INTEGER(0, "log-fd", &output_fd, 1682b070a547SArnaldo Carvalho de Melo "log output to fd, instead of stderr"), 16831f16c575SPeter Zijlstra OPT_STRING(0, "pre", &pre_cmd, "command", 16841f16c575SPeter Zijlstra "command to run prior to the measured command"), 16851f16c575SPeter Zijlstra OPT_STRING(0, "post", &post_cmd, "command", 16861f16c575SPeter Zijlstra "command to run after to the measured command"), 168713370a9bSStephane Eranian OPT_UINTEGER('I', "interval-print", &interval, 168813370a9bSStephane Eranian "print counts at regular interval in ms (>= 100)"), 1689d4304958SStephane Eranian OPT_SET_UINT(0, "per-socket", &aggr_mode, 169086ee6e18SStephane Eranian "aggregate counts per processor socket", AGGR_SOCKET), 169112c08a9fSStephane Eranian OPT_SET_UINT(0, "per-core", &aggr_mode, 169212c08a9fSStephane Eranian "aggregate counts per physical processor core", AGGR_CORE), 169341191688SAndi Kleen OPT_UINTEGER('D', "delay", &initial_delay, 169441191688SAndi Kleen "ms to wait before starting measurement after program start"), 1695b070a547SArnaldo Carvalho de Melo OPT_END() 1696b070a547SArnaldo Carvalho de Melo }; 1697b070a547SArnaldo Carvalho de Melo const char * const stat_usage[] = { 1698b070a547SArnaldo Carvalho de Melo "perf stat [<options>] [<command>]", 1699b070a547SArnaldo Carvalho de Melo NULL 1700b070a547SArnaldo Carvalho de Melo }; 1701cc03c542SNamhyung Kim int status = -EINVAL, run_idx; 17024aa9015fSStephane Eranian const char *mode; 170342202dd5SIngo Molnar 17045af52b51SStephane Eranian setlocale(LC_ALL, ""); 17055af52b51SStephane Eranian 1706334fe7a3SNamhyung Kim evsel_list = perf_evlist__new(); 1707361c99a6SArnaldo Carvalho de Melo if (evsel_list == NULL) 1708361c99a6SArnaldo Carvalho de Melo return -ENOMEM; 1709361c99a6SArnaldo Carvalho de Melo 1710a0541234SAnton Blanchard argc = parse_options(argc, argv, options, stat_usage, 1711a0541234SAnton Blanchard PARSE_OPT_STOP_AT_NON_OPTION); 1712d7470b6aSStephane Eranian 17134aa9015fSStephane Eranian output = stderr; 17144aa9015fSStephane Eranian if (output_name && strcmp(output_name, "-")) 17154aa9015fSStephane Eranian output = NULL; 17164aa9015fSStephane Eranian 171756f3bae7SJim Cromie if (output_name && output_fd) { 171856f3bae7SJim Cromie fprintf(stderr, "cannot use both --output and --log-fd\n"); 1719cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "o", 1); 1720cc03c542SNamhyung Kim parse_options_usage(NULL, options, "log-fd", 0); 1721cc03c542SNamhyung Kim goto out; 172256f3bae7SJim Cromie } 1723fc3e4d07SStephane Eranian 1724fc3e4d07SStephane Eranian if (output_fd < 0) { 1725fc3e4d07SStephane Eranian fprintf(stderr, "argument to --log-fd must be a > 0\n"); 1726cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "log-fd", 0); 1727cc03c542SNamhyung Kim goto out; 1728fc3e4d07SStephane Eranian } 1729fc3e4d07SStephane Eranian 17304aa9015fSStephane Eranian if (!output) { 17314aa9015fSStephane Eranian struct timespec tm; 17324aa9015fSStephane Eranian mode = append_file ? "a" : "w"; 17334aa9015fSStephane Eranian 17344aa9015fSStephane Eranian output = fopen(output_name, mode); 17354aa9015fSStephane Eranian if (!output) { 17364aa9015fSStephane Eranian perror("failed to create output file"); 1737fceda7feSDavid Ahern return -1; 17384aa9015fSStephane Eranian } 17394aa9015fSStephane Eranian clock_gettime(CLOCK_REALTIME, &tm); 17404aa9015fSStephane Eranian fprintf(output, "# started on %s\n", ctime(&tm.tv_sec)); 1741fc3e4d07SStephane Eranian } else if (output_fd > 0) { 174256f3bae7SJim Cromie mode = append_file ? "a" : "w"; 174356f3bae7SJim Cromie output = fdopen(output_fd, mode); 174456f3bae7SJim Cromie if (!output) { 174556f3bae7SJim Cromie perror("Failed opening logfd"); 174656f3bae7SJim Cromie return -errno; 174756f3bae7SJim Cromie } 17484aa9015fSStephane Eranian } 17494aa9015fSStephane Eranian 1750d4ffd04dSJim Cromie if (csv_sep) { 1751d7470b6aSStephane Eranian csv_output = true; 1752d4ffd04dSJim Cromie if (!strcmp(csv_sep, "\\t")) 1753d4ffd04dSJim Cromie csv_sep = "\t"; 1754d4ffd04dSJim Cromie } else 1755d7470b6aSStephane Eranian csv_sep = DEFAULT_SEPARATOR; 1756d7470b6aSStephane Eranian 1757d7470b6aSStephane Eranian /* 1758d7470b6aSStephane Eranian * let the spreadsheet do the pretty-printing 1759d7470b6aSStephane Eranian */ 1760d7470b6aSStephane Eranian if (csv_output) { 176161a9f324SJim Cromie /* User explicitly passed -B? */ 1762d7470b6aSStephane Eranian if (big_num_opt == 1) { 1763d7470b6aSStephane Eranian fprintf(stderr, "-B option not supported with -x\n"); 1764cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "B", 1); 1765cc03c542SNamhyung Kim parse_options_usage(NULL, options, "x", 1); 1766cc03c542SNamhyung Kim goto out; 1767d7470b6aSStephane Eranian } else /* Nope, so disable big number formatting */ 1768d7470b6aSStephane Eranian big_num = false; 1769d7470b6aSStephane Eranian } else if (big_num_opt == 0) /* User passed --no-big-num */ 1770d7470b6aSStephane Eranian big_num = false; 1771d7470b6aSStephane Eranian 1772602ad878SArnaldo Carvalho de Melo if (!argc && target__none(&target)) 177386470930SIngo Molnar usage_with_options(stat_usage, options); 1774ac3063bdSDavid Ahern 1775a7e191c3SFrederik Deweerdt if (run_count < 0) { 1776cc03c542SNamhyung Kim pr_err("Run count must be a positive number\n"); 1777cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "r", 1); 1778cc03c542SNamhyung Kim goto out; 1779a7e191c3SFrederik Deweerdt } else if (run_count == 0) { 1780a7e191c3SFrederik Deweerdt forever = true; 1781a7e191c3SFrederik Deweerdt run_count = 1; 1782a7e191c3SFrederik Deweerdt } 178386470930SIngo Molnar 1784023695d9SStephane Eranian /* no_aggr, cgroup are for system-wide only */ 1785602ad878SArnaldo Carvalho de Melo if ((aggr_mode != AGGR_GLOBAL || nr_cgroups) && 1786602ad878SArnaldo Carvalho de Melo !target__has_cpu(&target)) { 1787023695d9SStephane Eranian fprintf(stderr, "both cgroup and no-aggregation " 1788023695d9SStephane Eranian "modes only available in system-wide mode\n"); 1789023695d9SStephane Eranian 1790cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "G", 1); 1791cc03c542SNamhyung Kim parse_options_usage(NULL, options, "A", 1); 1792cc03c542SNamhyung Kim parse_options_usage(NULL, options, "a", 1); 1793cc03c542SNamhyung Kim goto out; 1794d7e7a451SStephane Eranian } 1795d7e7a451SStephane Eranian 17962cba3ffbSIngo Molnar if (add_default_attributes()) 1797c6264defSIngo Molnar goto out; 179886470930SIngo Molnar 1799602ad878SArnaldo Carvalho de Melo target__validate(&target); 18005c98d466SArnaldo Carvalho de Melo 180177a6f014SNamhyung Kim if (perf_evlist__create_maps(evsel_list, &target) < 0) { 1802602ad878SArnaldo Carvalho de Melo if (target__has_task(&target)) { 18035c98d466SArnaldo Carvalho de Melo pr_err("Problems finding threads of monitor\n"); 1804cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "p", 1); 1805cc03c542SNamhyung Kim parse_options_usage(NULL, options, "t", 1); 1806602ad878SArnaldo Carvalho de Melo } else if (target__has_cpu(&target)) { 180760d567e2SArnaldo Carvalho de Melo perror("failed to parse CPUs map"); 1808cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "C", 1); 1809cc03c542SNamhyung Kim parse_options_usage(NULL, options, "a", 1); 1810cc03c542SNamhyung Kim } 1811cc03c542SNamhyung Kim goto out; 181260d567e2SArnaldo Carvalho de Melo } 181313370a9bSStephane Eranian if (interval && interval < 100) { 181413370a9bSStephane Eranian pr_err("print interval must be >= 100ms\n"); 1815cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "I", 1); 181603ad9747SArnaldo Carvalho de Melo goto out; 181713370a9bSStephane Eranian } 1818c45c6ea2SStephane Eranian 1819d134ffb9SArnaldo Carvalho de Melo if (perf_evlist__alloc_stats(evsel_list, interval)) 182003ad9747SArnaldo Carvalho de Melo goto out; 1821d6d901c2SZhang, Yanmin 182286ee6e18SStephane Eranian if (perf_stat_init_aggr_mode()) 182303ad9747SArnaldo Carvalho de Melo goto out; 182486ee6e18SStephane Eranian 182586470930SIngo Molnar /* 182686470930SIngo Molnar * We dont want to block the signals - that would cause 182786470930SIngo Molnar * child tasks to inherit that and Ctrl-C would not work. 182886470930SIngo Molnar * What we want is for Ctrl-C to work in the exec()-ed 182986470930SIngo Molnar * task, but being ignored by perf stat itself: 183086470930SIngo Molnar */ 1831f7b7c26eSPeter Zijlstra atexit(sig_atexit); 1832a7e191c3SFrederik Deweerdt if (!forever) 183386470930SIngo Molnar signal(SIGINT, skip_signal); 183413370a9bSStephane Eranian signal(SIGCHLD, skip_signal); 183586470930SIngo Molnar signal(SIGALRM, skip_signal); 183686470930SIngo Molnar signal(SIGABRT, skip_signal); 183786470930SIngo Molnar 183842202dd5SIngo Molnar status = 0; 1839a7e191c3SFrederik Deweerdt for (run_idx = 0; forever || run_idx < run_count; run_idx++) { 184042202dd5SIngo Molnar if (run_count != 1 && verbose) 18414aa9015fSStephane Eranian fprintf(output, "[ perf stat: executing run #%d ... ]\n", 18424aa9015fSStephane Eranian run_idx + 1); 1843f9cef0a9SIngo Molnar 184442202dd5SIngo Molnar status = run_perf_stat(argc, argv); 1845a7e191c3SFrederik Deweerdt if (forever && status != -1) { 1846a7e191c3SFrederik Deweerdt print_stat(argc, argv); 1847d134ffb9SArnaldo Carvalho de Melo perf_stat__reset_stats(evsel_list); 1848a7e191c3SFrederik Deweerdt } 184942202dd5SIngo Molnar } 185042202dd5SIngo Molnar 1851a7e191c3SFrederik Deweerdt if (!forever && status != -1 && !interval) 185242202dd5SIngo Molnar print_stat(argc, argv); 1853d134ffb9SArnaldo Carvalho de Melo 1854d134ffb9SArnaldo Carvalho de Melo perf_evlist__free_stats(evsel_list); 18550015e2e1SArnaldo Carvalho de Melo out: 18560015e2e1SArnaldo Carvalho de Melo perf_evlist__delete(evsel_list); 185742202dd5SIngo Molnar return status; 185886470930SIngo Molnar } 1859