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 { 3941971f59fSJiri Olsa struct perf_counts_values *aggr = &evsel->counts->aggr; 3951971f59fSJiri Olsa 396060c4f9cSJiri Olsa switch (aggr_mode) { 397060c4f9cSJiri Olsa case AGGR_CORE: 398060c4f9cSJiri Olsa case AGGR_SOCKET: 399060c4f9cSJiri Olsa case AGGR_NONE: 400060c4f9cSJiri Olsa perf_evsel__compute_deltas(evsel, cpu, count); 401060c4f9cSJiri Olsa perf_counts_values__scale(count, scale, NULL); 402060c4f9cSJiri Olsa evsel->counts->cpu[cpu] = *count; 403060c4f9cSJiri Olsa update_shadow_stats(evsel, count->values); 404060c4f9cSJiri Olsa break; 405060c4f9cSJiri Olsa case AGGR_GLOBAL: 4061971f59fSJiri Olsa aggr->val += count->val; 4071971f59fSJiri Olsa if (scale) { 4081971f59fSJiri Olsa aggr->ena += count->ena; 4091971f59fSJiri Olsa aggr->run += count->run; 4101971f59fSJiri Olsa } 411060c4f9cSJiri Olsa default: 412060c4f9cSJiri Olsa break; 413060c4f9cSJiri Olsa } 414060c4f9cSJiri Olsa 415060c4f9cSJiri Olsa return 0; 416060c4f9cSJiri Olsa } 417060c4f9cSJiri Olsa 4181971f59fSJiri Olsa static int read_counter(struct perf_evsel *counter); 4191971f59fSJiri Olsa 420dcd9936aSIngo Molnar /* 42186470930SIngo Molnar * Read out the results of a single counter: 422f5b4a9c3SStephane Eranian * aggregate counts across CPUs in system-wide mode 42386470930SIngo Molnar */ 424c52b12edSArnaldo Carvalho de Melo static int read_counter_aggr(struct perf_evsel *counter) 42586470930SIngo Molnar { 4261971f59fSJiri Olsa struct perf_counts_values *aggr = &counter->counts->aggr; 42769aad6f1SArnaldo Carvalho de Melo struct perf_stat *ps = counter->priv; 428c52b12edSArnaldo Carvalho de Melo u64 *count = counter->counts->aggr.values; 429c52b12edSArnaldo Carvalho de Melo int i; 43086470930SIngo Molnar 4311971f59fSJiri Olsa aggr->val = aggr->ena = aggr->run = 0; 4321971f59fSJiri Olsa 4331971f59fSJiri Olsa if (read_counter(counter)) 434c52b12edSArnaldo Carvalho de Melo return -1; 4359e9772c4SPeter Zijlstra 4361971f59fSJiri Olsa perf_evsel__compute_deltas(counter, -1, aggr); 4371971f59fSJiri Olsa perf_counts_values__scale(aggr, scale, &counter->counts->scaled); 4381971f59fSJiri Olsa 4399e9772c4SPeter Zijlstra for (i = 0; i < 3; i++) 44069aad6f1SArnaldo Carvalho de Melo update_stats(&ps->res_stats[i], count[i]); 4419e9772c4SPeter Zijlstra 4429e9772c4SPeter Zijlstra if (verbose) { 4434aa9015fSStephane Eranian fprintf(output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n", 4447289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter), count[0], count[1], count[2]); 4459e9772c4SPeter Zijlstra } 4469e9772c4SPeter Zijlstra 44786470930SIngo Molnar /* 44886470930SIngo Molnar * Save the full runtime - to allow normalization during printout: 44986470930SIngo Molnar */ 450dcd9936aSIngo Molnar update_shadow_stats(counter, count); 451c52b12edSArnaldo Carvalho de Melo 452c52b12edSArnaldo Carvalho de Melo return 0; 453f5b4a9c3SStephane Eranian } 454f5b4a9c3SStephane Eranian 455f5b4a9c3SStephane Eranian /* 456f5b4a9c3SStephane Eranian * Read out the results of a single counter: 457f5b4a9c3SStephane Eranian * do not aggregate counts across CPUs in system-wide mode 458f5b4a9c3SStephane Eranian */ 459c52b12edSArnaldo Carvalho de Melo static int read_counter(struct perf_evsel *counter) 460f5b4a9c3SStephane Eranian { 4619bf1a529SJiri Olsa int nthreads = thread_map__nr(evsel_list->threads); 4629bf1a529SJiri Olsa int ncpus = perf_evsel__nr_cpus(counter); 4639bf1a529SJiri Olsa int cpu, thread; 464f5b4a9c3SStephane Eranian 4659bf1a529SJiri Olsa if (counter->system_wide) 4669bf1a529SJiri Olsa nthreads = 1; 4679bf1a529SJiri Olsa 4689bf1a529SJiri Olsa for (thread = 0; thread < nthreads; thread++) { 4699bf1a529SJiri Olsa for (cpu = 0; cpu < ncpus; cpu++) { 4709bf1a529SJiri Olsa if (perf_evsel__read_cb(counter, cpu, thread, read_cb)) 471c52b12edSArnaldo Carvalho de Melo return -1; 472f5b4a9c3SStephane Eranian } 4739bf1a529SJiri Olsa } 474c52b12edSArnaldo Carvalho de Melo 475c52b12edSArnaldo Carvalho de Melo return 0; 47686470930SIngo Molnar } 47786470930SIngo Molnar 47813370a9bSStephane Eranian static void print_interval(void) 47913370a9bSStephane Eranian { 48013370a9bSStephane Eranian static int num_print_interval; 48113370a9bSStephane Eranian struct perf_evsel *counter; 48213370a9bSStephane Eranian struct perf_stat *ps; 48313370a9bSStephane Eranian struct timespec ts, rs; 48413370a9bSStephane Eranian char prefix[64]; 48513370a9bSStephane Eranian 48686ee6e18SStephane Eranian if (aggr_mode == AGGR_GLOBAL) { 4870050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 48813370a9bSStephane Eranian ps = counter->priv; 48913370a9bSStephane Eranian memset(ps->res_stats, 0, sizeof(ps->res_stats)); 49013370a9bSStephane Eranian read_counter_aggr(counter); 49113370a9bSStephane Eranian } 49286ee6e18SStephane Eranian } else { 4930050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 49486ee6e18SStephane Eranian ps = counter->priv; 49586ee6e18SStephane Eranian memset(ps->res_stats, 0, sizeof(ps->res_stats)); 49686ee6e18SStephane Eranian read_counter(counter); 49713370a9bSStephane Eranian } 49886ee6e18SStephane Eranian } 49986ee6e18SStephane Eranian 50013370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ts); 50113370a9bSStephane Eranian diff_timespec(&rs, &ts, &ref_time); 50213370a9bSStephane Eranian sprintf(prefix, "%6lu.%09lu%s", rs.tv_sec, rs.tv_nsec, csv_sep); 50313370a9bSStephane Eranian 50413370a9bSStephane Eranian if (num_print_interval == 0 && !csv_output) { 50586ee6e18SStephane Eranian switch (aggr_mode) { 50686ee6e18SStephane Eranian case AGGR_SOCKET: 507410136f5SStephane Eranian fprintf(output, "# time socket cpus counts %*s events\n", unit_width, "unit"); 50886ee6e18SStephane Eranian break; 50912c08a9fSStephane Eranian case AGGR_CORE: 510410136f5SStephane Eranian fprintf(output, "# time core cpus counts %*s events\n", unit_width, "unit"); 51112c08a9fSStephane Eranian break; 51286ee6e18SStephane Eranian case AGGR_NONE: 513410136f5SStephane Eranian fprintf(output, "# time CPU counts %*s events\n", unit_width, "unit"); 51486ee6e18SStephane Eranian break; 51586ee6e18SStephane Eranian case AGGR_GLOBAL: 51686ee6e18SStephane Eranian default: 517410136f5SStephane Eranian fprintf(output, "# time counts %*s events\n", unit_width, "unit"); 51813370a9bSStephane Eranian } 51986ee6e18SStephane Eranian } 52013370a9bSStephane Eranian 52113370a9bSStephane Eranian if (++num_print_interval == 25) 52213370a9bSStephane Eranian num_print_interval = 0; 52313370a9bSStephane Eranian 52486ee6e18SStephane Eranian switch (aggr_mode) { 52512c08a9fSStephane Eranian case AGGR_CORE: 52686ee6e18SStephane Eranian case AGGR_SOCKET: 52786ee6e18SStephane Eranian print_aggr(prefix); 52886ee6e18SStephane Eranian break; 52986ee6e18SStephane Eranian case AGGR_NONE: 5300050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 53113370a9bSStephane Eranian print_counter(counter, prefix); 53286ee6e18SStephane Eranian break; 53386ee6e18SStephane Eranian case AGGR_GLOBAL: 53486ee6e18SStephane Eranian default: 5350050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 53613370a9bSStephane Eranian print_counter_aggr(counter, prefix); 53713370a9bSStephane Eranian } 5382bbf03f1SAndi Kleen 5392bbf03f1SAndi Kleen fflush(output); 54013370a9bSStephane Eranian } 54113370a9bSStephane Eranian 54241191688SAndi Kleen static void handle_initial_delay(void) 54341191688SAndi Kleen { 54441191688SAndi Kleen struct perf_evsel *counter; 54541191688SAndi Kleen 54641191688SAndi Kleen if (initial_delay) { 54741191688SAndi Kleen const int ncpus = cpu_map__nr(evsel_list->cpus), 54841191688SAndi Kleen nthreads = thread_map__nr(evsel_list->threads); 54941191688SAndi Kleen 55041191688SAndi Kleen usleep(initial_delay * 1000); 5510050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 55241191688SAndi Kleen perf_evsel__enable(counter, ncpus, nthreads); 55341191688SAndi Kleen } 55441191688SAndi Kleen } 55541191688SAndi Kleen 556f33cbe72SArnaldo Carvalho de Melo static volatile int workload_exec_errno; 5576af206fdSArnaldo Carvalho de Melo 5586af206fdSArnaldo Carvalho de Melo /* 5596af206fdSArnaldo Carvalho de Melo * perf_evlist__prepare_workload will send a SIGUSR1 5606af206fdSArnaldo Carvalho de Melo * if the fork fails, since we asked by setting its 5616af206fdSArnaldo Carvalho de Melo * want_signal to true. 5626af206fdSArnaldo Carvalho de Melo */ 563f33cbe72SArnaldo Carvalho de Melo static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info, 564f33cbe72SArnaldo Carvalho de Melo void *ucontext __maybe_unused) 5656af206fdSArnaldo Carvalho de Melo { 566f33cbe72SArnaldo Carvalho de Melo workload_exec_errno = info->si_value.sival_int; 5676af206fdSArnaldo Carvalho de Melo } 5686af206fdSArnaldo Carvalho de Melo 569acf28922SNamhyung Kim static int __run_perf_stat(int argc, const char **argv) 57086470930SIngo Molnar { 57156e52e85SArnaldo Carvalho de Melo char msg[512]; 57286470930SIngo Molnar unsigned long long t0, t1; 573cac21425SJiri Olsa struct perf_evsel *counter; 57413370a9bSStephane Eranian struct timespec ts; 575410136f5SStephane Eranian size_t l; 57642202dd5SIngo Molnar int status = 0; 5776be2850eSZhang, Yanmin const bool forks = (argc > 0); 57886470930SIngo Molnar 57913370a9bSStephane Eranian if (interval) { 58013370a9bSStephane Eranian ts.tv_sec = interval / 1000; 58113370a9bSStephane Eranian ts.tv_nsec = (interval % 1000) * 1000000; 58213370a9bSStephane Eranian } else { 58313370a9bSStephane Eranian ts.tv_sec = 1; 58413370a9bSStephane Eranian ts.tv_nsec = 0; 58513370a9bSStephane Eranian } 58613370a9bSStephane Eranian 587acf28922SNamhyung Kim if (forks) { 588735f7e0bSArnaldo Carvalho de Melo if (perf_evlist__prepare_workload(evsel_list, &target, argv, false, 589735f7e0bSArnaldo Carvalho de Melo workload_exec_failed_signal) < 0) { 590acf28922SNamhyung Kim perror("failed to prepare workload"); 591fceda7feSDavid Ahern return -1; 592051ae7f7SPaul Mackerras } 593d20a47e7SNamhyung Kim child_pid = evsel_list->workload.pid; 59460666c63SLiming Wang } 595051ae7f7SPaul Mackerras 5966a4bb04cSJiri Olsa if (group) 59763dab225SArnaldo Carvalho de Melo perf_evlist__set_leader(evsel_list); 5986a4bb04cSJiri Olsa 5990050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 600cac21425SJiri Olsa if (create_perf_stat_counter(counter) < 0) { 601979987a5SDavid Ahern /* 602979987a5SDavid Ahern * PPC returns ENXIO for HW counters until 2.6.37 603979987a5SDavid Ahern * (behavior changed with commit b0a873e). 604979987a5SDavid Ahern */ 60538f6ae1eSAnton Blanchard if (errno == EINVAL || errno == ENOSYS || 606979987a5SDavid Ahern errno == ENOENT || errno == EOPNOTSUPP || 607979987a5SDavid Ahern errno == ENXIO) { 608c63ca0c0SDavid Ahern if (verbose) 609c63ca0c0SDavid Ahern ui__warning("%s event is not supported by the kernel.\n", 6107289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 6112cee77c4SDavid Ahern counter->supported = false; 612ede70290SIngo Molnar continue; 613c63ca0c0SDavid Ahern } 614ede70290SIngo Molnar 61556e52e85SArnaldo Carvalho de Melo perf_evsel__open_strerror(counter, &target, 61656e52e85SArnaldo Carvalho de Melo errno, msg, sizeof(msg)); 61756e52e85SArnaldo Carvalho de Melo ui__error("%s\n", msg); 61856e52e85SArnaldo Carvalho de Melo 619084ab9f8SArnaldo Carvalho de Melo if (child_pid != -1) 620084ab9f8SArnaldo Carvalho de Melo kill(child_pid, SIGTERM); 621fceda7feSDavid Ahern 622084ab9f8SArnaldo Carvalho de Melo return -1; 623084ab9f8SArnaldo Carvalho de Melo } 6242cee77c4SDavid Ahern counter->supported = true; 625410136f5SStephane Eranian 626410136f5SStephane Eranian l = strlen(counter->unit); 627410136f5SStephane Eranian if (l > unit_width) 628410136f5SStephane Eranian unit_width = l; 62948290609SArnaldo Carvalho de Melo } 63086470930SIngo Molnar 6311491a632SArnaldo Carvalho de Melo if (perf_evlist__apply_filters(evsel_list)) { 632cfd748aeSFrederic Weisbecker error("failed to set filter with %d (%s)\n", errno, 633759e612bSMasami Hiramatsu strerror_r(errno, msg, sizeof(msg))); 634cfd748aeSFrederic Weisbecker return -1; 635cfd748aeSFrederic Weisbecker } 636cfd748aeSFrederic Weisbecker 63786470930SIngo Molnar /* 63886470930SIngo Molnar * Enable counters and exec the command: 63986470930SIngo Molnar */ 64086470930SIngo Molnar t0 = rdclock(); 64113370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ref_time); 64286470930SIngo Molnar 64360666c63SLiming Wang if (forks) { 644acf28922SNamhyung Kim perf_evlist__start_workload(evsel_list); 64541191688SAndi Kleen handle_initial_delay(); 646acf28922SNamhyung Kim 64713370a9bSStephane Eranian if (interval) { 64813370a9bSStephane Eranian while (!waitpid(child_pid, &status, WNOHANG)) { 64913370a9bSStephane Eranian nanosleep(&ts, NULL); 65013370a9bSStephane Eranian print_interval(); 65113370a9bSStephane Eranian } 65213370a9bSStephane Eranian } 65342202dd5SIngo Molnar wait(&status); 6546af206fdSArnaldo Carvalho de Melo 655f33cbe72SArnaldo Carvalho de Melo if (workload_exec_errno) { 656f33cbe72SArnaldo Carvalho de Melo const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg)); 657f33cbe72SArnaldo Carvalho de Melo pr_err("Workload failed: %s\n", emsg); 6586af206fdSArnaldo Carvalho de Melo return -1; 659f33cbe72SArnaldo Carvalho de Melo } 6606af206fdSArnaldo Carvalho de Melo 66133e49ea7SAndi Kleen if (WIFSIGNALED(status)) 66233e49ea7SAndi Kleen psignal(WTERMSIG(status), argv[0]); 66360666c63SLiming Wang } else { 66441191688SAndi Kleen handle_initial_delay(); 66513370a9bSStephane Eranian while (!done) { 66613370a9bSStephane Eranian nanosleep(&ts, NULL); 66713370a9bSStephane Eranian if (interval) 66813370a9bSStephane Eranian print_interval(); 66913370a9bSStephane Eranian } 67060666c63SLiming Wang } 67186470930SIngo Molnar 67286470930SIngo Molnar t1 = rdclock(); 67386470930SIngo Molnar 6749e9772c4SPeter Zijlstra update_stats(&walltime_nsecs_stats, t1 - t0); 67542202dd5SIngo Molnar 67686ee6e18SStephane Eranian if (aggr_mode == AGGR_GLOBAL) { 6770050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 678c52b12edSArnaldo Carvalho de Melo read_counter_aggr(counter); 6797ae92e74SYan, Zheng perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 680b3a319d5SNamhyung Kim thread_map__nr(evsel_list->threads)); 681c52b12edSArnaldo Carvalho de Melo } 68286ee6e18SStephane Eranian } else { 6830050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 68486ee6e18SStephane Eranian read_counter(counter); 68586ee6e18SStephane Eranian perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1); 68686ee6e18SStephane Eranian } 687c52b12edSArnaldo Carvalho de Melo } 688c52b12edSArnaldo Carvalho de Melo 68942202dd5SIngo Molnar return WEXITSTATUS(status); 69042202dd5SIngo Molnar } 69142202dd5SIngo Molnar 69241cde476SArnaldo Carvalho de Melo static int run_perf_stat(int argc, const char **argv) 6931f16c575SPeter Zijlstra { 6941f16c575SPeter Zijlstra int ret; 6951f16c575SPeter Zijlstra 6961f16c575SPeter Zijlstra if (pre_cmd) { 6971f16c575SPeter Zijlstra ret = system(pre_cmd); 6981f16c575SPeter Zijlstra if (ret) 6991f16c575SPeter Zijlstra return ret; 7001f16c575SPeter Zijlstra } 7011f16c575SPeter Zijlstra 7021f16c575SPeter Zijlstra if (sync_run) 7031f16c575SPeter Zijlstra sync(); 7041f16c575SPeter Zijlstra 7051f16c575SPeter Zijlstra ret = __run_perf_stat(argc, argv); 7061f16c575SPeter Zijlstra if (ret) 7071f16c575SPeter Zijlstra return ret; 7081f16c575SPeter Zijlstra 7091f16c575SPeter Zijlstra if (post_cmd) { 7101f16c575SPeter Zijlstra ret = system(post_cmd); 7111f16c575SPeter Zijlstra if (ret) 7121f16c575SPeter Zijlstra return ret; 7131f16c575SPeter Zijlstra } 7141f16c575SPeter Zijlstra 7151f16c575SPeter Zijlstra return ret; 7161f16c575SPeter Zijlstra } 7171f16c575SPeter Zijlstra 718f99844cbSIngo Molnar static void print_noise_pct(double total, double avg) 719f99844cbSIngo Molnar { 7200007eceaSXiao Guangrong double pct = rel_stddev_stats(total, avg); 721f99844cbSIngo Molnar 7223ae9a34dSZhengyu He if (csv_output) 7234aa9015fSStephane Eranian fprintf(output, "%s%.2f%%", csv_sep, pct); 724a1bca6ccSJim Cromie else if (pct) 7254aa9015fSStephane Eranian fprintf(output, " ( +-%6.2f%% )", pct); 726f99844cbSIngo Molnar } 727f99844cbSIngo Molnar 72869aad6f1SArnaldo Carvalho de Melo static void print_noise(struct perf_evsel *evsel, double avg) 72942202dd5SIngo Molnar { 73069aad6f1SArnaldo Carvalho de Melo struct perf_stat *ps; 73169aad6f1SArnaldo Carvalho de Melo 732849abde9SPeter Zijlstra if (run_count == 1) 733849abde9SPeter Zijlstra return; 734849abde9SPeter Zijlstra 73569aad6f1SArnaldo Carvalho de Melo ps = evsel->priv; 736f99844cbSIngo Molnar print_noise_pct(stddev_stats(&ps->res_stats[0]), avg); 73742202dd5SIngo Molnar } 73842202dd5SIngo Molnar 73912c08a9fSStephane Eranian static void aggr_printout(struct perf_evsel *evsel, int id, int nr) 74042202dd5SIngo Molnar { 74186ee6e18SStephane Eranian switch (aggr_mode) { 74212c08a9fSStephane Eranian case AGGR_CORE: 74312c08a9fSStephane Eranian fprintf(output, "S%d-C%*d%s%*d%s", 74412c08a9fSStephane Eranian cpu_map__id_to_socket(id), 74512c08a9fSStephane Eranian csv_output ? 0 : -8, 74612c08a9fSStephane Eranian cpu_map__id_to_cpu(id), 74712c08a9fSStephane Eranian csv_sep, 74812c08a9fSStephane Eranian csv_output ? 0 : 4, 74912c08a9fSStephane Eranian nr, 75012c08a9fSStephane Eranian csv_sep); 75112c08a9fSStephane Eranian break; 75286ee6e18SStephane Eranian case AGGR_SOCKET: 75386ee6e18SStephane Eranian fprintf(output, "S%*d%s%*d%s", 754d7e7a451SStephane Eranian csv_output ? 0 : -5, 75512c08a9fSStephane Eranian id, 756d7e7a451SStephane Eranian csv_sep, 757d7e7a451SStephane Eranian csv_output ? 0 : 4, 758d7e7a451SStephane Eranian nr, 759d7e7a451SStephane Eranian csv_sep); 76086ee6e18SStephane Eranian break; 76186ee6e18SStephane Eranian case AGGR_NONE: 76286ee6e18SStephane Eranian fprintf(output, "CPU%*d%s", 763d7470b6aSStephane Eranian csv_output ? 0 : -4, 76412c08a9fSStephane Eranian perf_evsel__cpus(evsel)->map[id], csv_sep); 76586ee6e18SStephane Eranian break; 76686ee6e18SStephane Eranian case AGGR_GLOBAL: 76786ee6e18SStephane Eranian default: 76886ee6e18SStephane Eranian break; 76986ee6e18SStephane Eranian } 77086ee6e18SStephane Eranian } 771d7470b6aSStephane Eranian 772da88c7f7SAndi Kleen static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg) 77386ee6e18SStephane Eranian { 77486ee6e18SStephane Eranian double msecs = avg / 1e6; 775410136f5SStephane Eranian const char *fmt_v, *fmt_n; 7764bbe5a61SDavid Ahern char name[25]; 77786ee6e18SStephane Eranian 778410136f5SStephane Eranian fmt_v = csv_output ? "%.6f%s" : "%18.6f%s"; 779410136f5SStephane Eranian fmt_n = csv_output ? "%s" : "%-25s"; 780410136f5SStephane Eranian 781da88c7f7SAndi Kleen aggr_printout(evsel, id, nr); 78286ee6e18SStephane Eranian 7834bbe5a61SDavid Ahern scnprintf(name, sizeof(name), "%s%s", 7844bbe5a61SDavid Ahern perf_evsel__name(evsel), csv_output ? "" : " (msec)"); 785410136f5SStephane Eranian 786410136f5SStephane Eranian fprintf(output, fmt_v, msecs, csv_sep); 787410136f5SStephane Eranian 788410136f5SStephane Eranian if (csv_output) 789410136f5SStephane Eranian fprintf(output, "%s%s", evsel->unit, csv_sep); 790410136f5SStephane Eranian else 791410136f5SStephane Eranian fprintf(output, "%-*s%s", unit_width, evsel->unit, csv_sep); 792410136f5SStephane Eranian 793410136f5SStephane Eranian fprintf(output, fmt_n, name); 794d7470b6aSStephane Eranian 795023695d9SStephane Eranian if (evsel->cgrp) 7964aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, evsel->cgrp->name); 797023695d9SStephane Eranian 79813370a9bSStephane Eranian if (csv_output || interval) 799d7470b6aSStephane Eranian return; 80042202dd5SIngo Molnar 801daec78a0SArnaldo Carvalho de Melo if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK)) 8024aa9015fSStephane Eranian fprintf(output, " # %8.3f CPUs utilized ", 8034aa9015fSStephane Eranian avg / avg_stats(&walltime_nsecs_stats)); 8049dac6a29SNamhyung Kim else 8059dac6a29SNamhyung Kim fprintf(output, " "); 80642202dd5SIngo Molnar } 80742202dd5SIngo Molnar 80815e6392fSNamhyung Kim /* used for get_ratio_color() */ 80915e6392fSNamhyung Kim enum grc_type { 81015e6392fSNamhyung Kim GRC_STALLED_CYCLES_FE, 81115e6392fSNamhyung Kim GRC_STALLED_CYCLES_BE, 81215e6392fSNamhyung Kim GRC_CACHE_MISSES, 81315e6392fSNamhyung Kim GRC_MAX_NR 81415e6392fSNamhyung Kim }; 81515e6392fSNamhyung Kim 81615e6392fSNamhyung Kim static const char *get_ratio_color(enum grc_type type, double ratio) 81715e6392fSNamhyung Kim { 81815e6392fSNamhyung Kim static const double grc_table[GRC_MAX_NR][3] = { 81915e6392fSNamhyung Kim [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 }, 82015e6392fSNamhyung Kim [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 }, 82115e6392fSNamhyung Kim [GRC_CACHE_MISSES] = { 20.0, 10.0, 5.0 }, 82215e6392fSNamhyung Kim }; 82315e6392fSNamhyung Kim const char *color = PERF_COLOR_NORMAL; 82415e6392fSNamhyung Kim 82515e6392fSNamhyung Kim if (ratio > grc_table[type][0]) 82615e6392fSNamhyung Kim color = PERF_COLOR_RED; 82715e6392fSNamhyung Kim else if (ratio > grc_table[type][1]) 82815e6392fSNamhyung Kim color = PERF_COLOR_MAGENTA; 82915e6392fSNamhyung Kim else if (ratio > grc_table[type][2]) 83015e6392fSNamhyung Kim color = PERF_COLOR_YELLOW; 83115e6392fSNamhyung Kim 83215e6392fSNamhyung Kim return color; 83315e6392fSNamhyung Kim } 83415e6392fSNamhyung Kim 8351d037ca1SIrina Tirdea static void print_stalled_cycles_frontend(int cpu, 8361d037ca1SIrina Tirdea struct perf_evsel *evsel 8371d037ca1SIrina Tirdea __maybe_unused, double avg) 838d3d1e86dSIngo Molnar { 839d3d1e86dSIngo Molnar double total, ratio = 0.0; 840d3d1e86dSIngo Molnar const char *color; 841d3d1e86dSIngo Molnar 842d3d1e86dSIngo Molnar total = avg_stats(&runtime_cycles_stats[cpu]); 843d3d1e86dSIngo Molnar 844d3d1e86dSIngo Molnar if (total) 845d3d1e86dSIngo Molnar ratio = avg / total * 100.0; 846d3d1e86dSIngo Molnar 84715e6392fSNamhyung Kim color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio); 848d3d1e86dSIngo Molnar 8494aa9015fSStephane Eranian fprintf(output, " # "); 8504aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 8514aa9015fSStephane Eranian fprintf(output, " frontend cycles idle "); 852d3d1e86dSIngo Molnar } 853d3d1e86dSIngo Molnar 8541d037ca1SIrina Tirdea static void print_stalled_cycles_backend(int cpu, 8551d037ca1SIrina Tirdea struct perf_evsel *evsel 8561d037ca1SIrina Tirdea __maybe_unused, double avg) 857a5d243d0SIngo Molnar { 858a5d243d0SIngo Molnar double total, ratio = 0.0; 859a5d243d0SIngo Molnar const char *color; 860a5d243d0SIngo Molnar 861a5d243d0SIngo Molnar total = avg_stats(&runtime_cycles_stats[cpu]); 862a5d243d0SIngo Molnar 863a5d243d0SIngo Molnar if (total) 864a5d243d0SIngo Molnar ratio = avg / total * 100.0; 865a5d243d0SIngo Molnar 86615e6392fSNamhyung Kim color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio); 867a5d243d0SIngo Molnar 8684aa9015fSStephane Eranian fprintf(output, " # "); 8694aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 8704aa9015fSStephane Eranian fprintf(output, " backend cycles idle "); 871a5d243d0SIngo Molnar } 872a5d243d0SIngo Molnar 8731d037ca1SIrina Tirdea static void print_branch_misses(int cpu, 8741d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 8751d037ca1SIrina Tirdea double avg) 876c78df6c1SIngo Molnar { 877c78df6c1SIngo Molnar double total, ratio = 0.0; 878c78df6c1SIngo Molnar const char *color; 879c78df6c1SIngo Molnar 880c78df6c1SIngo Molnar total = avg_stats(&runtime_branches_stats[cpu]); 881c78df6c1SIngo Molnar 882c78df6c1SIngo Molnar if (total) 883c78df6c1SIngo Molnar ratio = avg / total * 100.0; 884c78df6c1SIngo Molnar 88515e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 886c78df6c1SIngo Molnar 8874aa9015fSStephane Eranian fprintf(output, " # "); 8884aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 8894aa9015fSStephane Eranian fprintf(output, " of all branches "); 890c78df6c1SIngo Molnar } 891c78df6c1SIngo Molnar 8921d037ca1SIrina Tirdea static void print_l1_dcache_misses(int cpu, 8931d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 8941d037ca1SIrina Tirdea double avg) 8958bb6c79fSIngo Molnar { 8968bb6c79fSIngo Molnar double total, ratio = 0.0; 8978bb6c79fSIngo Molnar const char *color; 8988bb6c79fSIngo Molnar 8998bb6c79fSIngo Molnar total = avg_stats(&runtime_l1_dcache_stats[cpu]); 9008bb6c79fSIngo Molnar 9018bb6c79fSIngo Molnar if (total) 9028bb6c79fSIngo Molnar ratio = avg / total * 100.0; 9038bb6c79fSIngo Molnar 90415e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 9058bb6c79fSIngo Molnar 9064aa9015fSStephane Eranian fprintf(output, " # "); 9074aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9084aa9015fSStephane Eranian fprintf(output, " of all L1-dcache hits "); 9098bb6c79fSIngo Molnar } 9108bb6c79fSIngo Molnar 9111d037ca1SIrina Tirdea static void print_l1_icache_misses(int cpu, 9121d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9131d037ca1SIrina Tirdea double avg) 914c3305257SIngo Molnar { 915c3305257SIngo Molnar double total, ratio = 0.0; 916c3305257SIngo Molnar const char *color; 917c3305257SIngo Molnar 918c3305257SIngo Molnar total = avg_stats(&runtime_l1_icache_stats[cpu]); 919c3305257SIngo Molnar 920c3305257SIngo Molnar if (total) 921c3305257SIngo Molnar ratio = avg / total * 100.0; 922c3305257SIngo Molnar 92315e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 924c3305257SIngo Molnar 9254aa9015fSStephane Eranian fprintf(output, " # "); 9264aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9274aa9015fSStephane Eranian fprintf(output, " of all L1-icache hits "); 928c3305257SIngo Molnar } 929c3305257SIngo Molnar 9301d037ca1SIrina Tirdea static void print_dtlb_cache_misses(int cpu, 9311d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9321d037ca1SIrina Tirdea double avg) 933c3305257SIngo Molnar { 934c3305257SIngo Molnar double total, ratio = 0.0; 935c3305257SIngo Molnar const char *color; 936c3305257SIngo Molnar 937c3305257SIngo Molnar total = avg_stats(&runtime_dtlb_cache_stats[cpu]); 938c3305257SIngo Molnar 939c3305257SIngo Molnar if (total) 940c3305257SIngo Molnar ratio = avg / total * 100.0; 941c3305257SIngo Molnar 94215e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 943c3305257SIngo Molnar 9444aa9015fSStephane Eranian fprintf(output, " # "); 9454aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9464aa9015fSStephane Eranian fprintf(output, " of all dTLB cache hits "); 947c3305257SIngo Molnar } 948c3305257SIngo Molnar 9491d037ca1SIrina Tirdea static void print_itlb_cache_misses(int cpu, 9501d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9511d037ca1SIrina Tirdea double avg) 952c3305257SIngo Molnar { 953c3305257SIngo Molnar double total, ratio = 0.0; 954c3305257SIngo Molnar const char *color; 955c3305257SIngo Molnar 956c3305257SIngo Molnar total = avg_stats(&runtime_itlb_cache_stats[cpu]); 957c3305257SIngo Molnar 958c3305257SIngo Molnar if (total) 959c3305257SIngo Molnar ratio = avg / total * 100.0; 960c3305257SIngo Molnar 96115e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 962c3305257SIngo Molnar 9634aa9015fSStephane Eranian fprintf(output, " # "); 9644aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9654aa9015fSStephane Eranian fprintf(output, " of all iTLB cache hits "); 966c3305257SIngo Molnar } 967c3305257SIngo Molnar 9681d037ca1SIrina Tirdea static void print_ll_cache_misses(int cpu, 9691d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9701d037ca1SIrina Tirdea double avg) 971c3305257SIngo Molnar { 972c3305257SIngo Molnar double total, ratio = 0.0; 973c3305257SIngo Molnar const char *color; 974c3305257SIngo Molnar 975c3305257SIngo Molnar total = avg_stats(&runtime_ll_cache_stats[cpu]); 976c3305257SIngo Molnar 977c3305257SIngo Molnar if (total) 978c3305257SIngo Molnar ratio = avg / total * 100.0; 979c3305257SIngo Molnar 98015e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 981c3305257SIngo Molnar 9824aa9015fSStephane Eranian fprintf(output, " # "); 9834aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9844aa9015fSStephane Eranian fprintf(output, " of all LL-cache hits "); 985c3305257SIngo Molnar } 986c3305257SIngo Molnar 987da88c7f7SAndi Kleen static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg) 98842202dd5SIngo Molnar { 9894cabc3d1SAndi Kleen double total, ratio = 0.0, total2; 990410136f5SStephane Eranian double sc = evsel->scale; 991d7470b6aSStephane Eranian const char *fmt; 992da88c7f7SAndi Kleen int cpu = cpu_map__id_to_cpu(id); 993d7470b6aSStephane Eranian 994410136f5SStephane Eranian if (csv_output) { 995410136f5SStephane Eranian fmt = sc != 1.0 ? "%.2f%s" : "%.0f%s"; 996410136f5SStephane Eranian } else { 997410136f5SStephane Eranian if (big_num) 998410136f5SStephane Eranian fmt = sc != 1.0 ? "%'18.2f%s" : "%'18.0f%s"; 999d7470b6aSStephane Eranian else 1000410136f5SStephane Eranian fmt = sc != 1.0 ? "%18.2f%s" : "%18.0f%s"; 1001410136f5SStephane Eranian } 1002f5b4a9c3SStephane Eranian 1003da88c7f7SAndi Kleen aggr_printout(evsel, id, nr); 100486ee6e18SStephane Eranian 100586ee6e18SStephane Eranian if (aggr_mode == AGGR_GLOBAL) 1006f5b4a9c3SStephane Eranian cpu = 0; 1007c7f7fea3SIngo Molnar 1008410136f5SStephane Eranian fprintf(output, fmt, avg, csv_sep); 1009410136f5SStephane Eranian 1010410136f5SStephane Eranian if (evsel->unit) 1011410136f5SStephane Eranian fprintf(output, "%-*s%s", 1012410136f5SStephane Eranian csv_output ? 0 : unit_width, 1013410136f5SStephane Eranian evsel->unit, csv_sep); 1014410136f5SStephane Eranian 1015410136f5SStephane Eranian fprintf(output, "%-*s", csv_output ? 0 : 25, perf_evsel__name(evsel)); 1016d7470b6aSStephane Eranian 1017023695d9SStephane Eranian if (evsel->cgrp) 10184aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, evsel->cgrp->name); 1019023695d9SStephane Eranian 102013370a9bSStephane Eranian if (csv_output || interval) 1021d7470b6aSStephane Eranian return; 102242202dd5SIngo Molnar 1023daec78a0SArnaldo Carvalho de Melo if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) { 1024f5b4a9c3SStephane Eranian total = avg_stats(&runtime_cycles_stats[cpu]); 10253e7a0817SRamkumar Ramachandra if (total) { 1026c7f7fea3SIngo Molnar ratio = avg / total; 10274aa9015fSStephane Eranian fprintf(output, " # %5.2f insns per cycle ", ratio); 10283e7a0817SRamkumar Ramachandra } 1029d3d1e86dSIngo Molnar total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]); 1030d3d1e86dSIngo Molnar total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu])); 1031481f988aSIngo Molnar 1032481f988aSIngo Molnar if (total && avg) { 1033481f988aSIngo Molnar ratio = total / avg; 1034410136f5SStephane Eranian fprintf(output, "\n"); 1035410136f5SStephane Eranian if (aggr_mode == AGGR_NONE) 1036410136f5SStephane Eranian fprintf(output, " "); 1037410136f5SStephane Eranian fprintf(output, " # %5.2f stalled cycles per insn", ratio); 1038481f988aSIngo Molnar } 1039481f988aSIngo Molnar 1040daec78a0SArnaldo Carvalho de Melo } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) && 1041f5b4a9c3SStephane Eranian runtime_branches_stats[cpu].n != 0) { 1042c78df6c1SIngo Molnar print_branch_misses(cpu, evsel, avg); 10438bb6c79fSIngo Molnar } else if ( 10448bb6c79fSIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 10458bb6c79fSIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1D | 10468bb6c79fSIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 10478bb6c79fSIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1048c6264defSIngo Molnar runtime_l1_dcache_stats[cpu].n != 0) { 10498bb6c79fSIngo Molnar print_l1_dcache_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_L1I | 1053c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1054c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1055c3305257SIngo Molnar runtime_l1_icache_stats[cpu].n != 0) { 1056c3305257SIngo Molnar print_l1_icache_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_DTLB | 1060c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1061c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1062c3305257SIngo Molnar runtime_dtlb_cache_stats[cpu].n != 0) { 1063c3305257SIngo Molnar print_dtlb_cache_misses(cpu, evsel, avg); 1064c3305257SIngo Molnar } else if ( 1065c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1066c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_ITLB | 1067c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1068c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1069c3305257SIngo Molnar runtime_itlb_cache_stats[cpu].n != 0) { 1070c3305257SIngo Molnar print_itlb_cache_misses(cpu, evsel, avg); 1071c3305257SIngo Molnar } else if ( 1072c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1073c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_LL | 1074c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1075c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1076c3305257SIngo Molnar runtime_ll_cache_stats[cpu].n != 0) { 1077c3305257SIngo Molnar print_ll_cache_misses(cpu, evsel, avg); 1078d58f4c82SIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) && 1079d58f4c82SIngo Molnar runtime_cacherefs_stats[cpu].n != 0) { 1080d58f4c82SIngo Molnar total = avg_stats(&runtime_cacherefs_stats[cpu]); 1081d58f4c82SIngo Molnar 1082d58f4c82SIngo Molnar if (total) 1083d58f4c82SIngo Molnar ratio = avg * 100 / total; 1084d58f4c82SIngo Molnar 10854aa9015fSStephane Eranian fprintf(output, " # %8.3f %% of all cache refs ", ratio); 1086d58f4c82SIngo Molnar 1087d3d1e86dSIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) { 1088d3d1e86dSIngo Molnar print_stalled_cycles_frontend(cpu, evsel, avg); 1089129c04cbSIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) { 1090d3d1e86dSIngo Molnar print_stalled_cycles_backend(cpu, evsel, avg); 1091481f988aSIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) { 1092481f988aSIngo Molnar total = avg_stats(&runtime_nsecs_stats[cpu]); 1093481f988aSIngo Molnar 1094c458fe62SRamkumar Ramachandra if (total) { 1095c458fe62SRamkumar Ramachandra ratio = avg / total; 10964aa9015fSStephane Eranian fprintf(output, " # %8.3f GHz ", ratio); 1097c458fe62SRamkumar Ramachandra } 10984cabc3d1SAndi Kleen } else if (transaction_run && 10994cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX))) { 11004cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_stats[cpu]); 11014cabc3d1SAndi Kleen if (total) 11024cabc3d1SAndi Kleen fprintf(output, 11034cabc3d1SAndi Kleen " # %5.2f%% transactional cycles ", 11044cabc3d1SAndi Kleen 100.0 * (avg / total)); 11054cabc3d1SAndi Kleen } else if (transaction_run && 11064cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX_CP))) { 11074cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_stats[cpu]); 11084cabc3d1SAndi Kleen total2 = avg_stats(&runtime_cycles_in_tx_stats[cpu]); 11094cabc3d1SAndi Kleen if (total2 < avg) 11104cabc3d1SAndi Kleen total2 = avg; 11114cabc3d1SAndi Kleen if (total) 11124cabc3d1SAndi Kleen fprintf(output, 11134cabc3d1SAndi Kleen " # %5.2f%% aborted cycles ", 11144cabc3d1SAndi Kleen 100.0 * ((total2-avg) / total)); 11154cabc3d1SAndi Kleen } else if (transaction_run && 11164cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_TRANSACTION_START)) && 11174cabc3d1SAndi Kleen avg > 0 && 11184cabc3d1SAndi Kleen runtime_cycles_in_tx_stats[cpu].n != 0) { 11194cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_in_tx_stats[cpu]); 11204cabc3d1SAndi Kleen 11214cabc3d1SAndi Kleen if (total) 11224cabc3d1SAndi Kleen ratio = total / avg; 11234cabc3d1SAndi Kleen 11244cabc3d1SAndi Kleen fprintf(output, " # %8.0f cycles / transaction ", ratio); 11254cabc3d1SAndi Kleen } else if (transaction_run && 11264cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_ELISION_START)) && 11274cabc3d1SAndi Kleen avg > 0 && 11284cabc3d1SAndi Kleen runtime_cycles_in_tx_stats[cpu].n != 0) { 11294cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_in_tx_stats[cpu]); 11304cabc3d1SAndi Kleen 11314cabc3d1SAndi Kleen if (total) 11324cabc3d1SAndi Kleen ratio = total / avg; 11334cabc3d1SAndi Kleen 11344cabc3d1SAndi Kleen fprintf(output, " # %8.0f cycles / elision ", ratio); 1135481f988aSIngo Molnar } else if (runtime_nsecs_stats[cpu].n != 0) { 11365fde2523SNamhyung Kim char unit = 'M'; 11375fde2523SNamhyung Kim 1138481f988aSIngo Molnar total = avg_stats(&runtime_nsecs_stats[cpu]); 1139481f988aSIngo Molnar 1140481f988aSIngo Molnar if (total) 1141481f988aSIngo Molnar ratio = 1000.0 * avg / total; 11425fde2523SNamhyung Kim if (ratio < 0.001) { 11435fde2523SNamhyung Kim ratio *= 1000; 11445fde2523SNamhyung Kim unit = 'K'; 11455fde2523SNamhyung Kim } 1146481f988aSIngo Molnar 11475fde2523SNamhyung Kim fprintf(output, " # %8.3f %c/sec ", ratio, unit); 1148a5d243d0SIngo Molnar } else { 11494aa9015fSStephane Eranian fprintf(output, " "); 115042202dd5SIngo Molnar } 115142202dd5SIngo Molnar } 115242202dd5SIngo Molnar 115386ee6e18SStephane Eranian static void print_aggr(char *prefix) 1154d7e7a451SStephane Eranian { 1155d7e7a451SStephane Eranian struct perf_evsel *counter; 1156582ec082SStephane Eranian int cpu, cpu2, s, s2, id, nr; 1157410136f5SStephane Eranian double uval; 1158d7e7a451SStephane Eranian u64 ena, run, val; 1159d7e7a451SStephane Eranian 116086ee6e18SStephane Eranian if (!(aggr_map || aggr_get_id)) 1161d7e7a451SStephane Eranian return; 1162d7e7a451SStephane Eranian 116386ee6e18SStephane Eranian for (s = 0; s < aggr_map->nr; s++) { 116486ee6e18SStephane Eranian id = aggr_map->map[s]; 11650050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 1166d7e7a451SStephane Eranian val = ena = run = 0; 1167d7e7a451SStephane Eranian nr = 0; 1168d7e7a451SStephane Eranian for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1169582ec082SStephane Eranian cpu2 = perf_evsel__cpus(counter)->map[cpu]; 1170582ec082SStephane Eranian s2 = aggr_get_id(evsel_list->cpus, cpu2); 117186ee6e18SStephane Eranian if (s2 != id) 1172d7e7a451SStephane Eranian continue; 1173d7e7a451SStephane Eranian val += counter->counts->cpu[cpu].val; 1174d7e7a451SStephane Eranian ena += counter->counts->cpu[cpu].ena; 1175d7e7a451SStephane Eranian run += counter->counts->cpu[cpu].run; 1176d7e7a451SStephane Eranian nr++; 1177d7e7a451SStephane Eranian } 1178d7e7a451SStephane Eranian if (prefix) 1179d7e7a451SStephane Eranian fprintf(output, "%s", prefix); 1180d7e7a451SStephane Eranian 1181d7e7a451SStephane Eranian if (run == 0 || ena == 0) { 1182582ec082SStephane Eranian aggr_printout(counter, id, nr); 118386ee6e18SStephane Eranian 1184410136f5SStephane Eranian fprintf(output, "%*s%s", 1185d7e7a451SStephane Eranian csv_output ? 0 : 18, 1186d7e7a451SStephane Eranian counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1187410136f5SStephane Eranian csv_sep); 1188410136f5SStephane Eranian 1189410136f5SStephane Eranian fprintf(output, "%-*s%s", 1190410136f5SStephane Eranian csv_output ? 0 : unit_width, 1191410136f5SStephane Eranian counter->unit, csv_sep); 1192410136f5SStephane Eranian 1193410136f5SStephane Eranian fprintf(output, "%*s", 1194410136f5SStephane Eranian csv_output ? 0 : -25, 1195d7e7a451SStephane Eranian perf_evsel__name(counter)); 119686ee6e18SStephane Eranian 1197d7e7a451SStephane Eranian if (counter->cgrp) 1198d7e7a451SStephane Eranian fprintf(output, "%s%s", 1199d7e7a451SStephane Eranian csv_sep, counter->cgrp->name); 1200d7e7a451SStephane Eranian 1201d7e7a451SStephane Eranian fputc('\n', output); 1202d7e7a451SStephane Eranian continue; 1203d7e7a451SStephane Eranian } 1204410136f5SStephane Eranian uval = val * counter->scale; 1205d7e7a451SStephane Eranian 1206d7e7a451SStephane Eranian if (nsec_counter(counter)) 1207410136f5SStephane Eranian nsec_printout(id, nr, counter, uval); 1208d7e7a451SStephane Eranian else 1209410136f5SStephane Eranian abs_printout(id, nr, counter, uval); 1210d7e7a451SStephane Eranian 1211d7e7a451SStephane Eranian if (!csv_output) { 1212d7e7a451SStephane Eranian print_noise(counter, 1.0); 1213d7e7a451SStephane Eranian 1214d7e7a451SStephane Eranian if (run != ena) 1215d7e7a451SStephane Eranian fprintf(output, " (%.2f%%)", 1216d7e7a451SStephane Eranian 100.0 * run / ena); 1217d7e7a451SStephane Eranian } 1218d7e7a451SStephane Eranian fputc('\n', output); 1219d7e7a451SStephane Eranian } 1220d7e7a451SStephane Eranian } 1221d7e7a451SStephane Eranian } 1222d7e7a451SStephane Eranian 122342202dd5SIngo Molnar /* 122442202dd5SIngo Molnar * Print out the results of a single counter: 1225f5b4a9c3SStephane Eranian * aggregated counts in system-wide mode 122642202dd5SIngo Molnar */ 122713370a9bSStephane Eranian static void print_counter_aggr(struct perf_evsel *counter, char *prefix) 122842202dd5SIngo Molnar { 122969aad6f1SArnaldo Carvalho de Melo struct perf_stat *ps = counter->priv; 123069aad6f1SArnaldo Carvalho de Melo double avg = avg_stats(&ps->res_stats[0]); 1231c52b12edSArnaldo Carvalho de Melo int scaled = counter->counts->scaled; 1232410136f5SStephane Eranian double uval; 123342202dd5SIngo Molnar 123413370a9bSStephane Eranian if (prefix) 123513370a9bSStephane Eranian fprintf(output, "%s", prefix); 123613370a9bSStephane Eranian 123742202dd5SIngo Molnar if (scaled == -1) { 1238410136f5SStephane Eranian fprintf(output, "%*s%s", 1239d7470b6aSStephane Eranian csv_output ? 0 : 18, 12402cee77c4SDavid Ahern counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1241410136f5SStephane Eranian csv_sep); 1242410136f5SStephane Eranian fprintf(output, "%-*s%s", 1243410136f5SStephane Eranian csv_output ? 0 : unit_width, 1244410136f5SStephane Eranian counter->unit, csv_sep); 1245410136f5SStephane Eranian fprintf(output, "%*s", 1246410136f5SStephane Eranian csv_output ? 0 : -25, 12477289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 1248023695d9SStephane Eranian 1249023695d9SStephane Eranian if (counter->cgrp) 12504aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, counter->cgrp->name); 1251023695d9SStephane Eranian 12524aa9015fSStephane Eranian fputc('\n', output); 125342202dd5SIngo Molnar return; 125442202dd5SIngo Molnar } 125542202dd5SIngo Molnar 1256410136f5SStephane Eranian uval = avg * counter->scale; 1257410136f5SStephane Eranian 125842202dd5SIngo Molnar if (nsec_counter(counter)) 1259410136f5SStephane Eranian nsec_printout(-1, 0, counter, uval); 126042202dd5SIngo Molnar else 1261410136f5SStephane Eranian abs_printout(-1, 0, counter, uval); 1262849abde9SPeter Zijlstra 12633ae9a34dSZhengyu He print_noise(counter, avg); 12643ae9a34dSZhengyu He 1265d7470b6aSStephane Eranian if (csv_output) { 12664aa9015fSStephane Eranian fputc('\n', output); 1267d7470b6aSStephane Eranian return; 1268d7470b6aSStephane Eranian } 1269d7470b6aSStephane Eranian 1270506d4bc8SPeter Zijlstra if (scaled) { 1271506d4bc8SPeter Zijlstra double avg_enabled, avg_running; 1272506d4bc8SPeter Zijlstra 127369aad6f1SArnaldo Carvalho de Melo avg_enabled = avg_stats(&ps->res_stats[1]); 127469aad6f1SArnaldo Carvalho de Melo avg_running = avg_stats(&ps->res_stats[2]); 1275506d4bc8SPeter Zijlstra 12764aa9015fSStephane Eranian fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled); 1277506d4bc8SPeter Zijlstra } 12784aa9015fSStephane Eranian fprintf(output, "\n"); 127942202dd5SIngo Molnar } 128042202dd5SIngo Molnar 1281f5b4a9c3SStephane Eranian /* 1282f5b4a9c3SStephane Eranian * Print out the results of a single counter: 1283f5b4a9c3SStephane Eranian * does not use aggregated count in system-wide 1284f5b4a9c3SStephane Eranian */ 128513370a9bSStephane Eranian static void print_counter(struct perf_evsel *counter, char *prefix) 1286f5b4a9c3SStephane Eranian { 1287f5b4a9c3SStephane Eranian u64 ena, run, val; 1288410136f5SStephane Eranian double uval; 1289f5b4a9c3SStephane Eranian int cpu; 1290f5b4a9c3SStephane Eranian 12917ae92e74SYan, Zheng for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1292c52b12edSArnaldo Carvalho de Melo val = counter->counts->cpu[cpu].val; 1293c52b12edSArnaldo Carvalho de Melo ena = counter->counts->cpu[cpu].ena; 1294c52b12edSArnaldo Carvalho de Melo run = counter->counts->cpu[cpu].run; 129513370a9bSStephane Eranian 129613370a9bSStephane Eranian if (prefix) 129713370a9bSStephane Eranian fprintf(output, "%s", prefix); 129813370a9bSStephane Eranian 1299f5b4a9c3SStephane Eranian if (run == 0 || ena == 0) { 1300410136f5SStephane Eranian fprintf(output, "CPU%*d%s%*s%s", 1301d7470b6aSStephane Eranian csv_output ? 0 : -4, 13027ae92e74SYan, Zheng perf_evsel__cpus(counter)->map[cpu], csv_sep, 1303d7470b6aSStephane Eranian csv_output ? 0 : 18, 13042cee77c4SDavid Ahern counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1305410136f5SStephane Eranian csv_sep); 1306410136f5SStephane Eranian 1307410136f5SStephane Eranian fprintf(output, "%-*s%s", 1308410136f5SStephane Eranian csv_output ? 0 : unit_width, 1309410136f5SStephane Eranian counter->unit, csv_sep); 1310410136f5SStephane Eranian 1311410136f5SStephane Eranian fprintf(output, "%*s", 1312410136f5SStephane Eranian csv_output ? 0 : -25, 13137289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 1314f5b4a9c3SStephane Eranian 1315023695d9SStephane Eranian if (counter->cgrp) 13164aa9015fSStephane Eranian fprintf(output, "%s%s", 13174aa9015fSStephane Eranian csv_sep, counter->cgrp->name); 1318023695d9SStephane Eranian 13194aa9015fSStephane Eranian fputc('\n', output); 1320f5b4a9c3SStephane Eranian continue; 1321f5b4a9c3SStephane Eranian } 1322f5b4a9c3SStephane Eranian 1323410136f5SStephane Eranian uval = val * counter->scale; 1324410136f5SStephane Eranian 1325f5b4a9c3SStephane Eranian if (nsec_counter(counter)) 1326410136f5SStephane Eranian nsec_printout(cpu, 0, counter, uval); 1327f5b4a9c3SStephane Eranian else 1328410136f5SStephane Eranian abs_printout(cpu, 0, counter, uval); 1329f5b4a9c3SStephane Eranian 1330d7470b6aSStephane Eranian if (!csv_output) { 1331f5b4a9c3SStephane Eranian print_noise(counter, 1.0); 1332f5b4a9c3SStephane Eranian 1333c6264defSIngo Molnar if (run != ena) 13344aa9015fSStephane Eranian fprintf(output, " (%.2f%%)", 13354aa9015fSStephane Eranian 100.0 * run / ena); 1336d7470b6aSStephane Eranian } 13374aa9015fSStephane Eranian fputc('\n', output); 1338f5b4a9c3SStephane Eranian } 1339f5b4a9c3SStephane Eranian } 1340f5b4a9c3SStephane Eranian 134142202dd5SIngo Molnar static void print_stat(int argc, const char **argv) 134242202dd5SIngo Molnar { 134369aad6f1SArnaldo Carvalho de Melo struct perf_evsel *counter; 134469aad6f1SArnaldo Carvalho de Melo int i; 134542202dd5SIngo Molnar 134686470930SIngo Molnar fflush(stdout); 134786470930SIngo Molnar 1348d7470b6aSStephane Eranian if (!csv_output) { 13494aa9015fSStephane Eranian fprintf(output, "\n"); 13504aa9015fSStephane Eranian fprintf(output, " Performance counter stats for "); 135162d3b617SDavid Ahern if (target.system_wide) 135262d3b617SDavid Ahern fprintf(output, "\'system wide"); 135362d3b617SDavid Ahern else if (target.cpu_list) 135462d3b617SDavid Ahern fprintf(output, "\'CPU(s) %s", target.cpu_list); 1355602ad878SArnaldo Carvalho de Melo else if (!target__has_task(&target)) { 13564aa9015fSStephane Eranian fprintf(output, "\'%s", argv[0]); 135786470930SIngo Molnar for (i = 1; i < argc; i++) 13584aa9015fSStephane Eranian fprintf(output, " %s", argv[i]); 135920f946b4SNamhyung Kim } else if (target.pid) 136020f946b4SNamhyung Kim fprintf(output, "process id \'%s", target.pid); 1361d6d901c2SZhang, Yanmin else 136220f946b4SNamhyung Kim fprintf(output, "thread id \'%s", target.tid); 136386470930SIngo Molnar 13644aa9015fSStephane Eranian fprintf(output, "\'"); 136542202dd5SIngo Molnar if (run_count > 1) 13664aa9015fSStephane Eranian fprintf(output, " (%d runs)", run_count); 13674aa9015fSStephane Eranian fprintf(output, ":\n\n"); 1368d7470b6aSStephane Eranian } 136986470930SIngo Molnar 137086ee6e18SStephane Eranian switch (aggr_mode) { 137112c08a9fSStephane Eranian case AGGR_CORE: 137286ee6e18SStephane Eranian case AGGR_SOCKET: 137386ee6e18SStephane Eranian print_aggr(NULL); 137486ee6e18SStephane Eranian break; 137586ee6e18SStephane Eranian case AGGR_GLOBAL: 13760050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 137713370a9bSStephane Eranian print_counter_aggr(counter, NULL); 137886ee6e18SStephane Eranian break; 137986ee6e18SStephane Eranian case AGGR_NONE: 13800050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 138186ee6e18SStephane Eranian print_counter(counter, NULL); 138286ee6e18SStephane Eranian break; 138386ee6e18SStephane Eranian default: 138486ee6e18SStephane Eranian break; 1385f5b4a9c3SStephane Eranian } 138686470930SIngo Molnar 1387d7470b6aSStephane Eranian if (!csv_output) { 1388c3305257SIngo Molnar if (!null_run) 13894aa9015fSStephane Eranian fprintf(output, "\n"); 13904aa9015fSStephane Eranian fprintf(output, " %17.9f seconds time elapsed", 1391506d4bc8SPeter Zijlstra avg_stats(&walltime_nsecs_stats)/1e9); 1392566747e6SIngo Molnar if (run_count > 1) { 13934aa9015fSStephane Eranian fprintf(output, " "); 1394f99844cbSIngo Molnar print_noise_pct(stddev_stats(&walltime_nsecs_stats), 1395506d4bc8SPeter Zijlstra avg_stats(&walltime_nsecs_stats)); 1396566747e6SIngo Molnar } 13974aa9015fSStephane Eranian fprintf(output, "\n\n"); 139886470930SIngo Molnar } 1399d7470b6aSStephane Eranian } 140086470930SIngo Molnar 1401f7b7c26eSPeter Zijlstra static volatile int signr = -1; 1402f7b7c26eSPeter Zijlstra 140386470930SIngo Molnar static void skip_signal(int signo) 140486470930SIngo Molnar { 140513370a9bSStephane Eranian if ((child_pid == -1) || interval) 140660666c63SLiming Wang done = 1; 140760666c63SLiming Wang 1408f7b7c26eSPeter Zijlstra signr = signo; 1409d07f0b12SStephane Eranian /* 1410d07f0b12SStephane Eranian * render child_pid harmless 1411d07f0b12SStephane Eranian * won't send SIGTERM to a random 1412d07f0b12SStephane Eranian * process in case of race condition 1413d07f0b12SStephane Eranian * and fast PID recycling 1414d07f0b12SStephane Eranian */ 1415d07f0b12SStephane Eranian child_pid = -1; 1416f7b7c26eSPeter Zijlstra } 1417f7b7c26eSPeter Zijlstra 1418f7b7c26eSPeter Zijlstra static void sig_atexit(void) 1419f7b7c26eSPeter Zijlstra { 1420d07f0b12SStephane Eranian sigset_t set, oset; 1421d07f0b12SStephane Eranian 1422d07f0b12SStephane Eranian /* 1423d07f0b12SStephane Eranian * avoid race condition with SIGCHLD handler 1424d07f0b12SStephane Eranian * in skip_signal() which is modifying child_pid 1425d07f0b12SStephane Eranian * goal is to avoid send SIGTERM to a random 1426d07f0b12SStephane Eranian * process 1427d07f0b12SStephane Eranian */ 1428d07f0b12SStephane Eranian sigemptyset(&set); 1429d07f0b12SStephane Eranian sigaddset(&set, SIGCHLD); 1430d07f0b12SStephane Eranian sigprocmask(SIG_BLOCK, &set, &oset); 1431d07f0b12SStephane Eranian 1432933da83aSChris Wilson if (child_pid != -1) 1433933da83aSChris Wilson kill(child_pid, SIGTERM); 1434933da83aSChris Wilson 1435d07f0b12SStephane Eranian sigprocmask(SIG_SETMASK, &oset, NULL); 1436d07f0b12SStephane Eranian 1437f7b7c26eSPeter Zijlstra if (signr == -1) 1438f7b7c26eSPeter Zijlstra return; 1439f7b7c26eSPeter Zijlstra 1440f7b7c26eSPeter Zijlstra signal(signr, SIG_DFL); 1441f7b7c26eSPeter Zijlstra kill(getpid(), signr); 144286470930SIngo Molnar } 144386470930SIngo Molnar 14441d037ca1SIrina Tirdea static int stat__set_big_num(const struct option *opt __maybe_unused, 14451d037ca1SIrina Tirdea const char *s __maybe_unused, int unset) 1446d7470b6aSStephane Eranian { 1447d7470b6aSStephane Eranian big_num_opt = unset ? 0 : 1; 1448d7470b6aSStephane Eranian return 0; 1449d7470b6aSStephane Eranian } 1450d7470b6aSStephane Eranian 145186ee6e18SStephane Eranian static int perf_stat_init_aggr_mode(void) 145286ee6e18SStephane Eranian { 145386ee6e18SStephane Eranian switch (aggr_mode) { 145486ee6e18SStephane Eranian case AGGR_SOCKET: 145586ee6e18SStephane Eranian if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) { 145686ee6e18SStephane Eranian perror("cannot build socket map"); 145786ee6e18SStephane Eranian return -1; 145886ee6e18SStephane Eranian } 145986ee6e18SStephane Eranian aggr_get_id = cpu_map__get_socket; 146086ee6e18SStephane Eranian break; 146112c08a9fSStephane Eranian case AGGR_CORE: 146212c08a9fSStephane Eranian if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) { 146312c08a9fSStephane Eranian perror("cannot build core map"); 146412c08a9fSStephane Eranian return -1; 146512c08a9fSStephane Eranian } 146612c08a9fSStephane Eranian aggr_get_id = cpu_map__get_core; 146712c08a9fSStephane Eranian break; 146886ee6e18SStephane Eranian case AGGR_NONE: 146986ee6e18SStephane Eranian case AGGR_GLOBAL: 147086ee6e18SStephane Eranian default: 147186ee6e18SStephane Eranian break; 147286ee6e18SStephane Eranian } 147386ee6e18SStephane Eranian return 0; 147486ee6e18SStephane Eranian } 147586ee6e18SStephane Eranian 14764cabc3d1SAndi Kleen static int setup_events(const char * const *attrs, unsigned len) 14774cabc3d1SAndi Kleen { 14784cabc3d1SAndi Kleen unsigned i; 14794cabc3d1SAndi Kleen 14804cabc3d1SAndi Kleen for (i = 0; i < len; i++) { 14814cabc3d1SAndi Kleen if (parse_events(evsel_list, attrs[i])) 14824cabc3d1SAndi Kleen return -1; 14834cabc3d1SAndi Kleen } 14844cabc3d1SAndi Kleen return 0; 14854cabc3d1SAndi Kleen } 148686ee6e18SStephane Eranian 14872cba3ffbSIngo Molnar /* 14882cba3ffbSIngo Molnar * Add default attributes, if there were no attributes specified or 14892cba3ffbSIngo Molnar * if -d/--detailed, -d -d or -d -d -d is used: 14902cba3ffbSIngo Molnar */ 14912cba3ffbSIngo Molnar static int add_default_attributes(void) 14922cba3ffbSIngo Molnar { 1493b070a547SArnaldo Carvalho de Melo struct perf_event_attr default_attrs[] = { 1494b070a547SArnaldo Carvalho de Melo 1495b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK }, 1496b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES }, 1497b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS }, 1498b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS }, 1499b070a547SArnaldo Carvalho de Melo 1500b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES }, 1501b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND }, 1502b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND }, 1503b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS }, 1504b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS }, 1505b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES }, 1506b070a547SArnaldo Carvalho de Melo 1507b070a547SArnaldo Carvalho de Melo }; 1508b070a547SArnaldo Carvalho de Melo 1509b070a547SArnaldo Carvalho de Melo /* 1510b070a547SArnaldo Carvalho de Melo * Detailed stats (-d), covering the L1 and last level data caches: 1511b070a547SArnaldo Carvalho de Melo */ 1512b070a547SArnaldo Carvalho de Melo struct perf_event_attr detailed_attrs[] = { 1513b070a547SArnaldo Carvalho de Melo 1514b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1515b070a547SArnaldo Carvalho de Melo .config = 1516b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1517b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1518b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1519b070a547SArnaldo Carvalho de Melo 1520b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1521b070a547SArnaldo Carvalho de Melo .config = 1522b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1523b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1524b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1525b070a547SArnaldo Carvalho de Melo 1526b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1527b070a547SArnaldo Carvalho de Melo .config = 1528b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 1529b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1530b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1531b070a547SArnaldo Carvalho de Melo 1532b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1533b070a547SArnaldo Carvalho de Melo .config = 1534b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 1535b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1536b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1537b070a547SArnaldo Carvalho de Melo }; 1538b070a547SArnaldo Carvalho de Melo 1539b070a547SArnaldo Carvalho de Melo /* 1540b070a547SArnaldo Carvalho de Melo * Very detailed stats (-d -d), covering the instruction cache and the TLB caches: 1541b070a547SArnaldo Carvalho de Melo */ 1542b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_detailed_attrs[] = { 1543b070a547SArnaldo Carvalho de Melo 1544b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1545b070a547SArnaldo Carvalho de Melo .config = 1546b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 1547b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1548b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1549b070a547SArnaldo Carvalho de Melo 1550b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1551b070a547SArnaldo Carvalho de Melo .config = 1552b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 1553b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1554b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1555b070a547SArnaldo Carvalho de Melo 1556b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1557b070a547SArnaldo Carvalho de Melo .config = 1558b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 1559b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1560b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1561b070a547SArnaldo Carvalho de Melo 1562b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1563b070a547SArnaldo Carvalho de Melo .config = 1564b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 1565b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1566b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1567b070a547SArnaldo Carvalho de Melo 1568b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1569b070a547SArnaldo Carvalho de Melo .config = 1570b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 1571b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1572b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1573b070a547SArnaldo Carvalho de Melo 1574b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1575b070a547SArnaldo Carvalho de Melo .config = 1576b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 1577b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1578b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1579b070a547SArnaldo Carvalho de Melo 1580b070a547SArnaldo Carvalho de Melo }; 1581b070a547SArnaldo Carvalho de Melo 1582b070a547SArnaldo Carvalho de Melo /* 1583b070a547SArnaldo Carvalho de Melo * Very, very detailed stats (-d -d -d), adding prefetch events: 1584b070a547SArnaldo Carvalho de Melo */ 1585b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_very_detailed_attrs[] = { 1586b070a547SArnaldo Carvalho de Melo 1587b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1588b070a547SArnaldo Carvalho de Melo .config = 1589b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1590b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 1591b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1592b070a547SArnaldo Carvalho de Melo 1593b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1594b070a547SArnaldo Carvalho de Melo .config = 1595b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1596b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 1597b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1598b070a547SArnaldo Carvalho de Melo }; 1599b070a547SArnaldo Carvalho de Melo 16002cba3ffbSIngo Molnar /* Set attrs if no event is selected and !null_run: */ 16012cba3ffbSIngo Molnar if (null_run) 16022cba3ffbSIngo Molnar return 0; 16032cba3ffbSIngo Molnar 16044cabc3d1SAndi Kleen if (transaction_run) { 16054cabc3d1SAndi Kleen int err; 16064cabc3d1SAndi Kleen if (pmu_have_event("cpu", "cycles-ct") && 16074cabc3d1SAndi Kleen pmu_have_event("cpu", "el-start")) 16084cabc3d1SAndi Kleen err = setup_events(transaction_attrs, 16094cabc3d1SAndi Kleen ARRAY_SIZE(transaction_attrs)); 16104cabc3d1SAndi Kleen else 16114cabc3d1SAndi Kleen err = setup_events(transaction_limited_attrs, 16124cabc3d1SAndi Kleen ARRAY_SIZE(transaction_limited_attrs)); 16134cabc3d1SAndi Kleen if (err < 0) { 16144cabc3d1SAndi Kleen fprintf(stderr, "Cannot set up transaction events\n"); 16154cabc3d1SAndi Kleen return -1; 16164cabc3d1SAndi Kleen } 16174cabc3d1SAndi Kleen return 0; 16184cabc3d1SAndi Kleen } 16194cabc3d1SAndi Kleen 16202cba3ffbSIngo Molnar if (!evsel_list->nr_entries) { 162179695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, default_attrs) < 0) 16222cba3ffbSIngo Molnar return -1; 16232cba3ffbSIngo Molnar } 16242cba3ffbSIngo Molnar 16252cba3ffbSIngo Molnar /* Detailed events get appended to the event list: */ 16262cba3ffbSIngo Molnar 16272cba3ffbSIngo Molnar if (detailed_run < 1) 16282cba3ffbSIngo Molnar return 0; 16292cba3ffbSIngo Molnar 16302cba3ffbSIngo Molnar /* Append detailed run extra attributes: */ 163179695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0) 16322cba3ffbSIngo Molnar return -1; 16332cba3ffbSIngo Molnar 16342cba3ffbSIngo Molnar if (detailed_run < 2) 16352cba3ffbSIngo Molnar return 0; 16362cba3ffbSIngo Molnar 16372cba3ffbSIngo Molnar /* Append very detailed run extra attributes: */ 163879695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0) 16392cba3ffbSIngo Molnar return -1; 16402cba3ffbSIngo Molnar 16412cba3ffbSIngo Molnar if (detailed_run < 3) 16422cba3ffbSIngo Molnar return 0; 16432cba3ffbSIngo Molnar 16442cba3ffbSIngo Molnar /* Append very, very detailed run extra attributes: */ 164579695e1bSArnaldo Carvalho de Melo return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs); 16462cba3ffbSIngo Molnar } 16472cba3ffbSIngo Molnar 16481d037ca1SIrina Tirdea int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused) 164986470930SIngo Molnar { 16501f16c575SPeter Zijlstra bool append_file = false; 1651b070a547SArnaldo Carvalho de Melo int output_fd = 0; 1652b070a547SArnaldo Carvalho de Melo const char *output_name = NULL; 1653b070a547SArnaldo Carvalho de Melo const struct option options[] = { 16544cabc3d1SAndi Kleen OPT_BOOLEAN('T', "transaction", &transaction_run, 16554cabc3d1SAndi Kleen "hardware transaction statistics"), 1656b070a547SArnaldo Carvalho de Melo OPT_CALLBACK('e', "event", &evsel_list, "event", 1657b070a547SArnaldo Carvalho de Melo "event selector. use 'perf list' to list available events", 1658b070a547SArnaldo Carvalho de Melo parse_events_option), 1659b070a547SArnaldo Carvalho de Melo OPT_CALLBACK(0, "filter", &evsel_list, "filter", 1660b070a547SArnaldo Carvalho de Melo "event filter", parse_filter), 1661b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('i', "no-inherit", &no_inherit, 1662b070a547SArnaldo Carvalho de Melo "child tasks do not inherit counters"), 1663b070a547SArnaldo Carvalho de Melo OPT_STRING('p', "pid", &target.pid, "pid", 1664b070a547SArnaldo Carvalho de Melo "stat events on existing process id"), 1665b070a547SArnaldo Carvalho de Melo OPT_STRING('t', "tid", &target.tid, "tid", 1666b070a547SArnaldo Carvalho de Melo "stat events on existing thread id"), 1667b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('a', "all-cpus", &target.system_wide, 1668b070a547SArnaldo Carvalho de Melo "system-wide collection from all CPUs"), 1669b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('g', "group", &group, 1670b070a547SArnaldo Carvalho de Melo "put the counters into a counter group"), 1671b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('c', "scale", &scale, "scale/normalize counters"), 1672b070a547SArnaldo Carvalho de Melo OPT_INCR('v', "verbose", &verbose, 1673b070a547SArnaldo Carvalho de Melo "be more verbose (show counter open errors, etc)"), 1674b070a547SArnaldo Carvalho de Melo OPT_INTEGER('r', "repeat", &run_count, 1675a7e191c3SFrederik Deweerdt "repeat command and print average + stddev (max: 100, forever: 0)"), 1676b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('n', "null", &null_run, 1677b070a547SArnaldo Carvalho de Melo "null run - dont start any counters"), 1678b070a547SArnaldo Carvalho de Melo OPT_INCR('d', "detailed", &detailed_run, 1679b070a547SArnaldo Carvalho de Melo "detailed run - start a lot of events"), 1680b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('S', "sync", &sync_run, 1681b070a547SArnaldo Carvalho de Melo "call sync() before starting a run"), 1682b070a547SArnaldo Carvalho de Melo OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 1683b070a547SArnaldo Carvalho de Melo "print large numbers with thousands\' separators", 1684b070a547SArnaldo Carvalho de Melo stat__set_big_num), 1685b070a547SArnaldo Carvalho de Melo OPT_STRING('C', "cpu", &target.cpu_list, "cpu", 1686b070a547SArnaldo Carvalho de Melo "list of cpus to monitor in system-wide"), 168786ee6e18SStephane Eranian OPT_SET_UINT('A', "no-aggr", &aggr_mode, 168886ee6e18SStephane Eranian "disable CPU count aggregation", AGGR_NONE), 1689b070a547SArnaldo Carvalho de Melo OPT_STRING('x', "field-separator", &csv_sep, "separator", 1690b070a547SArnaldo Carvalho de Melo "print counts with custom separator"), 1691b070a547SArnaldo Carvalho de Melo OPT_CALLBACK('G', "cgroup", &evsel_list, "name", 1692b070a547SArnaldo Carvalho de Melo "monitor event in cgroup name only", parse_cgroups), 1693b070a547SArnaldo Carvalho de Melo OPT_STRING('o', "output", &output_name, "file", "output file name"), 1694b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN(0, "append", &append_file, "append to the output file"), 1695b070a547SArnaldo Carvalho de Melo OPT_INTEGER(0, "log-fd", &output_fd, 1696b070a547SArnaldo Carvalho de Melo "log output to fd, instead of stderr"), 16971f16c575SPeter Zijlstra OPT_STRING(0, "pre", &pre_cmd, "command", 16981f16c575SPeter Zijlstra "command to run prior to the measured command"), 16991f16c575SPeter Zijlstra OPT_STRING(0, "post", &post_cmd, "command", 17001f16c575SPeter Zijlstra "command to run after to the measured command"), 170113370a9bSStephane Eranian OPT_UINTEGER('I', "interval-print", &interval, 170213370a9bSStephane Eranian "print counts at regular interval in ms (>= 100)"), 1703d4304958SStephane Eranian OPT_SET_UINT(0, "per-socket", &aggr_mode, 170486ee6e18SStephane Eranian "aggregate counts per processor socket", AGGR_SOCKET), 170512c08a9fSStephane Eranian OPT_SET_UINT(0, "per-core", &aggr_mode, 170612c08a9fSStephane Eranian "aggregate counts per physical processor core", AGGR_CORE), 170741191688SAndi Kleen OPT_UINTEGER('D', "delay", &initial_delay, 170841191688SAndi Kleen "ms to wait before starting measurement after program start"), 1709b070a547SArnaldo Carvalho de Melo OPT_END() 1710b070a547SArnaldo Carvalho de Melo }; 1711b070a547SArnaldo Carvalho de Melo const char * const stat_usage[] = { 1712b070a547SArnaldo Carvalho de Melo "perf stat [<options>] [<command>]", 1713b070a547SArnaldo Carvalho de Melo NULL 1714b070a547SArnaldo Carvalho de Melo }; 1715cc03c542SNamhyung Kim int status = -EINVAL, run_idx; 17164aa9015fSStephane Eranian const char *mode; 171742202dd5SIngo Molnar 17185af52b51SStephane Eranian setlocale(LC_ALL, ""); 17195af52b51SStephane Eranian 1720334fe7a3SNamhyung Kim evsel_list = perf_evlist__new(); 1721361c99a6SArnaldo Carvalho de Melo if (evsel_list == NULL) 1722361c99a6SArnaldo Carvalho de Melo return -ENOMEM; 1723361c99a6SArnaldo Carvalho de Melo 1724a0541234SAnton Blanchard argc = parse_options(argc, argv, options, stat_usage, 1725a0541234SAnton Blanchard PARSE_OPT_STOP_AT_NON_OPTION); 1726d7470b6aSStephane Eranian 17274aa9015fSStephane Eranian output = stderr; 17284aa9015fSStephane Eranian if (output_name && strcmp(output_name, "-")) 17294aa9015fSStephane Eranian output = NULL; 17304aa9015fSStephane Eranian 173156f3bae7SJim Cromie if (output_name && output_fd) { 173256f3bae7SJim Cromie fprintf(stderr, "cannot use both --output and --log-fd\n"); 1733cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "o", 1); 1734cc03c542SNamhyung Kim parse_options_usage(NULL, options, "log-fd", 0); 1735cc03c542SNamhyung Kim goto out; 173656f3bae7SJim Cromie } 1737fc3e4d07SStephane Eranian 1738fc3e4d07SStephane Eranian if (output_fd < 0) { 1739fc3e4d07SStephane Eranian fprintf(stderr, "argument to --log-fd must be a > 0\n"); 1740cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "log-fd", 0); 1741cc03c542SNamhyung Kim goto out; 1742fc3e4d07SStephane Eranian } 1743fc3e4d07SStephane Eranian 17444aa9015fSStephane Eranian if (!output) { 17454aa9015fSStephane Eranian struct timespec tm; 17464aa9015fSStephane Eranian mode = append_file ? "a" : "w"; 17474aa9015fSStephane Eranian 17484aa9015fSStephane Eranian output = fopen(output_name, mode); 17494aa9015fSStephane Eranian if (!output) { 17504aa9015fSStephane Eranian perror("failed to create output file"); 1751fceda7feSDavid Ahern return -1; 17524aa9015fSStephane Eranian } 17534aa9015fSStephane Eranian clock_gettime(CLOCK_REALTIME, &tm); 17544aa9015fSStephane Eranian fprintf(output, "# started on %s\n", ctime(&tm.tv_sec)); 1755fc3e4d07SStephane Eranian } else if (output_fd > 0) { 175656f3bae7SJim Cromie mode = append_file ? "a" : "w"; 175756f3bae7SJim Cromie output = fdopen(output_fd, mode); 175856f3bae7SJim Cromie if (!output) { 175956f3bae7SJim Cromie perror("Failed opening logfd"); 176056f3bae7SJim Cromie return -errno; 176156f3bae7SJim Cromie } 17624aa9015fSStephane Eranian } 17634aa9015fSStephane Eranian 1764d4ffd04dSJim Cromie if (csv_sep) { 1765d7470b6aSStephane Eranian csv_output = true; 1766d4ffd04dSJim Cromie if (!strcmp(csv_sep, "\\t")) 1767d4ffd04dSJim Cromie csv_sep = "\t"; 1768d4ffd04dSJim Cromie } else 1769d7470b6aSStephane Eranian csv_sep = DEFAULT_SEPARATOR; 1770d7470b6aSStephane Eranian 1771d7470b6aSStephane Eranian /* 1772d7470b6aSStephane Eranian * let the spreadsheet do the pretty-printing 1773d7470b6aSStephane Eranian */ 1774d7470b6aSStephane Eranian if (csv_output) { 177561a9f324SJim Cromie /* User explicitly passed -B? */ 1776d7470b6aSStephane Eranian if (big_num_opt == 1) { 1777d7470b6aSStephane Eranian fprintf(stderr, "-B option not supported with -x\n"); 1778cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "B", 1); 1779cc03c542SNamhyung Kim parse_options_usage(NULL, options, "x", 1); 1780cc03c542SNamhyung Kim goto out; 1781d7470b6aSStephane Eranian } else /* Nope, so disable big number formatting */ 1782d7470b6aSStephane Eranian big_num = false; 1783d7470b6aSStephane Eranian } else if (big_num_opt == 0) /* User passed --no-big-num */ 1784d7470b6aSStephane Eranian big_num = false; 1785d7470b6aSStephane Eranian 1786602ad878SArnaldo Carvalho de Melo if (!argc && target__none(&target)) 178786470930SIngo Molnar usage_with_options(stat_usage, options); 1788ac3063bdSDavid Ahern 1789a7e191c3SFrederik Deweerdt if (run_count < 0) { 1790cc03c542SNamhyung Kim pr_err("Run count must be a positive number\n"); 1791cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "r", 1); 1792cc03c542SNamhyung Kim goto out; 1793a7e191c3SFrederik Deweerdt } else if (run_count == 0) { 1794a7e191c3SFrederik Deweerdt forever = true; 1795a7e191c3SFrederik Deweerdt run_count = 1; 1796a7e191c3SFrederik Deweerdt } 179786470930SIngo Molnar 1798023695d9SStephane Eranian /* no_aggr, cgroup are for system-wide only */ 1799602ad878SArnaldo Carvalho de Melo if ((aggr_mode != AGGR_GLOBAL || nr_cgroups) && 1800602ad878SArnaldo Carvalho de Melo !target__has_cpu(&target)) { 1801023695d9SStephane Eranian fprintf(stderr, "both cgroup and no-aggregation " 1802023695d9SStephane Eranian "modes only available in system-wide mode\n"); 1803023695d9SStephane Eranian 1804cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "G", 1); 1805cc03c542SNamhyung Kim parse_options_usage(NULL, options, "A", 1); 1806cc03c542SNamhyung Kim parse_options_usage(NULL, options, "a", 1); 1807cc03c542SNamhyung Kim goto out; 1808d7e7a451SStephane Eranian } 1809d7e7a451SStephane Eranian 18102cba3ffbSIngo Molnar if (add_default_attributes()) 1811c6264defSIngo Molnar goto out; 181286470930SIngo Molnar 1813602ad878SArnaldo Carvalho de Melo target__validate(&target); 18145c98d466SArnaldo Carvalho de Melo 181577a6f014SNamhyung Kim if (perf_evlist__create_maps(evsel_list, &target) < 0) { 1816602ad878SArnaldo Carvalho de Melo if (target__has_task(&target)) { 18175c98d466SArnaldo Carvalho de Melo pr_err("Problems finding threads of monitor\n"); 1818cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "p", 1); 1819cc03c542SNamhyung Kim parse_options_usage(NULL, options, "t", 1); 1820602ad878SArnaldo Carvalho de Melo } else if (target__has_cpu(&target)) { 182160d567e2SArnaldo Carvalho de Melo perror("failed to parse CPUs map"); 1822cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "C", 1); 1823cc03c542SNamhyung Kim parse_options_usage(NULL, options, "a", 1); 1824cc03c542SNamhyung Kim } 1825cc03c542SNamhyung Kim goto out; 182660d567e2SArnaldo Carvalho de Melo } 182713370a9bSStephane Eranian if (interval && interval < 100) { 182813370a9bSStephane Eranian pr_err("print interval must be >= 100ms\n"); 1829cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "I", 1); 183003ad9747SArnaldo Carvalho de Melo goto out; 183113370a9bSStephane Eranian } 1832c45c6ea2SStephane Eranian 1833d134ffb9SArnaldo Carvalho de Melo if (perf_evlist__alloc_stats(evsel_list, interval)) 183403ad9747SArnaldo Carvalho de Melo goto out; 1835d6d901c2SZhang, Yanmin 183686ee6e18SStephane Eranian if (perf_stat_init_aggr_mode()) 183703ad9747SArnaldo Carvalho de Melo goto out; 183886ee6e18SStephane Eranian 183986470930SIngo Molnar /* 184086470930SIngo Molnar * We dont want to block the signals - that would cause 184186470930SIngo Molnar * child tasks to inherit that and Ctrl-C would not work. 184286470930SIngo Molnar * What we want is for Ctrl-C to work in the exec()-ed 184386470930SIngo Molnar * task, but being ignored by perf stat itself: 184486470930SIngo Molnar */ 1845f7b7c26eSPeter Zijlstra atexit(sig_atexit); 1846a7e191c3SFrederik Deweerdt if (!forever) 184786470930SIngo Molnar signal(SIGINT, skip_signal); 184813370a9bSStephane Eranian signal(SIGCHLD, skip_signal); 184986470930SIngo Molnar signal(SIGALRM, skip_signal); 185086470930SIngo Molnar signal(SIGABRT, skip_signal); 185186470930SIngo Molnar 185242202dd5SIngo Molnar status = 0; 1853a7e191c3SFrederik Deweerdt for (run_idx = 0; forever || run_idx < run_count; run_idx++) { 185442202dd5SIngo Molnar if (run_count != 1 && verbose) 18554aa9015fSStephane Eranian fprintf(output, "[ perf stat: executing run #%d ... ]\n", 18564aa9015fSStephane Eranian run_idx + 1); 1857f9cef0a9SIngo Molnar 185842202dd5SIngo Molnar status = run_perf_stat(argc, argv); 1859a7e191c3SFrederik Deweerdt if (forever && status != -1) { 1860a7e191c3SFrederik Deweerdt print_stat(argc, argv); 1861d134ffb9SArnaldo Carvalho de Melo perf_stat__reset_stats(evsel_list); 1862a7e191c3SFrederik Deweerdt } 186342202dd5SIngo Molnar } 186442202dd5SIngo Molnar 1865a7e191c3SFrederik Deweerdt if (!forever && status != -1 && !interval) 186642202dd5SIngo Molnar print_stat(argc, argv); 1867d134ffb9SArnaldo Carvalho de Melo 1868d134ffb9SArnaldo Carvalho de Melo perf_evlist__free_stats(evsel_list); 18690015e2e1SArnaldo Carvalho de Melo out: 18700015e2e1SArnaldo Carvalho de Melo perf_evlist__delete(evsel_list); 187142202dd5SIngo Molnar return status; 187286470930SIngo Molnar } 1873