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 391779d0b99SJiri Olsa static void zero_per_pkg(struct perf_evsel *counter) 392779d0b99SJiri Olsa { 393779d0b99SJiri Olsa if (counter->per_pkg_mask) 394779d0b99SJiri Olsa memset(counter->per_pkg_mask, 0, MAX_NR_CPUS); 395779d0b99SJiri Olsa } 396779d0b99SJiri Olsa 397779d0b99SJiri Olsa static int check_per_pkg(struct perf_evsel *counter, int cpu, bool *skip) 398779d0b99SJiri Olsa { 399779d0b99SJiri Olsa unsigned long *mask = counter->per_pkg_mask; 400779d0b99SJiri Olsa struct cpu_map *cpus = perf_evsel__cpus(counter); 401779d0b99SJiri Olsa int s; 402779d0b99SJiri Olsa 403779d0b99SJiri Olsa *skip = false; 404779d0b99SJiri Olsa 405779d0b99SJiri Olsa if (!counter->per_pkg) 406779d0b99SJiri Olsa return 0; 407779d0b99SJiri Olsa 408779d0b99SJiri Olsa if (cpu_map__empty(cpus)) 409779d0b99SJiri Olsa return 0; 410779d0b99SJiri Olsa 411779d0b99SJiri Olsa if (!mask) { 412779d0b99SJiri Olsa mask = zalloc(MAX_NR_CPUS); 413779d0b99SJiri Olsa if (!mask) 414779d0b99SJiri Olsa return -ENOMEM; 415779d0b99SJiri Olsa 416779d0b99SJiri Olsa counter->per_pkg_mask = mask; 417779d0b99SJiri Olsa } 418779d0b99SJiri Olsa 419779d0b99SJiri Olsa s = cpu_map__get_socket(cpus, cpu); 420779d0b99SJiri Olsa if (s < 0) 421779d0b99SJiri Olsa return -1; 422779d0b99SJiri Olsa 423779d0b99SJiri Olsa *skip = test_and_set_bit(s, mask) == 1; 424779d0b99SJiri Olsa return 0; 425779d0b99SJiri Olsa } 426779d0b99SJiri Olsa 427060c4f9cSJiri Olsa static int read_cb(struct perf_evsel *evsel, int cpu, int thread __maybe_unused, 428060c4f9cSJiri Olsa struct perf_counts_values *count) 429060c4f9cSJiri Olsa { 4301971f59fSJiri Olsa struct perf_counts_values *aggr = &evsel->counts->aggr; 431779d0b99SJiri Olsa static struct perf_counts_values zero; 432779d0b99SJiri Olsa bool skip = false; 433779d0b99SJiri Olsa 434779d0b99SJiri Olsa if (check_per_pkg(evsel, cpu, &skip)) { 435779d0b99SJiri Olsa pr_err("failed to read per-pkg counter\n"); 436779d0b99SJiri Olsa return -1; 437779d0b99SJiri Olsa } 438779d0b99SJiri Olsa 439779d0b99SJiri Olsa if (skip) 440779d0b99SJiri Olsa count = &zero; 4411971f59fSJiri Olsa 442060c4f9cSJiri Olsa switch (aggr_mode) { 443060c4f9cSJiri Olsa case AGGR_CORE: 444060c4f9cSJiri Olsa case AGGR_SOCKET: 445060c4f9cSJiri Olsa case AGGR_NONE: 4466c0345b7SJiri Olsa if (!evsel->snapshot) 447060c4f9cSJiri Olsa perf_evsel__compute_deltas(evsel, cpu, count); 448060c4f9cSJiri Olsa perf_counts_values__scale(count, scale, NULL); 449060c4f9cSJiri Olsa evsel->counts->cpu[cpu] = *count; 450060c4f9cSJiri Olsa update_shadow_stats(evsel, count->values); 451060c4f9cSJiri Olsa break; 452060c4f9cSJiri Olsa case AGGR_GLOBAL: 4531971f59fSJiri Olsa aggr->val += count->val; 4541971f59fSJiri Olsa if (scale) { 4551971f59fSJiri Olsa aggr->ena += count->ena; 4561971f59fSJiri Olsa aggr->run += count->run; 4571971f59fSJiri Olsa } 458060c4f9cSJiri Olsa default: 459060c4f9cSJiri Olsa break; 460060c4f9cSJiri Olsa } 461060c4f9cSJiri Olsa 462060c4f9cSJiri Olsa return 0; 463060c4f9cSJiri Olsa } 464060c4f9cSJiri Olsa 4651971f59fSJiri Olsa static int read_counter(struct perf_evsel *counter); 4661971f59fSJiri Olsa 467dcd9936aSIngo Molnar /* 46886470930SIngo Molnar * Read out the results of a single counter: 469f5b4a9c3SStephane Eranian * aggregate counts across CPUs in system-wide mode 47086470930SIngo Molnar */ 471c52b12edSArnaldo Carvalho de Melo static int read_counter_aggr(struct perf_evsel *counter) 47286470930SIngo Molnar { 4731971f59fSJiri Olsa struct perf_counts_values *aggr = &counter->counts->aggr; 47469aad6f1SArnaldo Carvalho de Melo struct perf_stat *ps = counter->priv; 475c52b12edSArnaldo Carvalho de Melo u64 *count = counter->counts->aggr.values; 476c52b12edSArnaldo Carvalho de Melo int i; 47786470930SIngo Molnar 4781971f59fSJiri Olsa aggr->val = aggr->ena = aggr->run = 0; 4791971f59fSJiri Olsa 4801971f59fSJiri Olsa if (read_counter(counter)) 481c52b12edSArnaldo Carvalho de Melo return -1; 4829e9772c4SPeter Zijlstra 4836c0345b7SJiri Olsa if (!counter->snapshot) 4841971f59fSJiri Olsa perf_evsel__compute_deltas(counter, -1, aggr); 4851971f59fSJiri Olsa perf_counts_values__scale(aggr, scale, &counter->counts->scaled); 4861971f59fSJiri Olsa 4879e9772c4SPeter Zijlstra for (i = 0; i < 3; i++) 48869aad6f1SArnaldo Carvalho de Melo update_stats(&ps->res_stats[i], count[i]); 4899e9772c4SPeter Zijlstra 4909e9772c4SPeter Zijlstra if (verbose) { 4914aa9015fSStephane Eranian fprintf(output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n", 4927289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter), count[0], count[1], count[2]); 4939e9772c4SPeter Zijlstra } 4949e9772c4SPeter Zijlstra 49586470930SIngo Molnar /* 49686470930SIngo Molnar * Save the full runtime - to allow normalization during printout: 49786470930SIngo Molnar */ 498dcd9936aSIngo Molnar update_shadow_stats(counter, count); 499c52b12edSArnaldo Carvalho de Melo 500c52b12edSArnaldo Carvalho de Melo return 0; 501f5b4a9c3SStephane Eranian } 502f5b4a9c3SStephane Eranian 503f5b4a9c3SStephane Eranian /* 504f5b4a9c3SStephane Eranian * Read out the results of a single counter: 505f5b4a9c3SStephane Eranian * do not aggregate counts across CPUs in system-wide mode 506f5b4a9c3SStephane Eranian */ 507c52b12edSArnaldo Carvalho de Melo static int read_counter(struct perf_evsel *counter) 508f5b4a9c3SStephane Eranian { 5099bf1a529SJiri Olsa int nthreads = thread_map__nr(evsel_list->threads); 5109bf1a529SJiri Olsa int ncpus = perf_evsel__nr_cpus(counter); 5119bf1a529SJiri Olsa int cpu, thread; 512f5b4a9c3SStephane Eranian 5139bf1a529SJiri Olsa if (counter->system_wide) 5149bf1a529SJiri Olsa nthreads = 1; 5159bf1a529SJiri Olsa 516779d0b99SJiri Olsa if (counter->per_pkg) 517779d0b99SJiri Olsa zero_per_pkg(counter); 518779d0b99SJiri Olsa 5199bf1a529SJiri Olsa for (thread = 0; thread < nthreads; thread++) { 5209bf1a529SJiri Olsa for (cpu = 0; cpu < ncpus; cpu++) { 5219bf1a529SJiri Olsa if (perf_evsel__read_cb(counter, cpu, thread, read_cb)) 522c52b12edSArnaldo Carvalho de Melo return -1; 523f5b4a9c3SStephane Eranian } 5249bf1a529SJiri Olsa } 525c52b12edSArnaldo Carvalho de Melo 526c52b12edSArnaldo Carvalho de Melo return 0; 52786470930SIngo Molnar } 52886470930SIngo Molnar 52913370a9bSStephane Eranian static void print_interval(void) 53013370a9bSStephane Eranian { 53113370a9bSStephane Eranian static int num_print_interval; 53213370a9bSStephane Eranian struct perf_evsel *counter; 53313370a9bSStephane Eranian struct perf_stat *ps; 53413370a9bSStephane Eranian struct timespec ts, rs; 53513370a9bSStephane Eranian char prefix[64]; 53613370a9bSStephane Eranian 53786ee6e18SStephane Eranian if (aggr_mode == AGGR_GLOBAL) { 5380050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 53913370a9bSStephane Eranian ps = counter->priv; 54013370a9bSStephane Eranian memset(ps->res_stats, 0, sizeof(ps->res_stats)); 54113370a9bSStephane Eranian read_counter_aggr(counter); 54213370a9bSStephane Eranian } 54386ee6e18SStephane Eranian } else { 5440050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 54586ee6e18SStephane Eranian ps = counter->priv; 54686ee6e18SStephane Eranian memset(ps->res_stats, 0, sizeof(ps->res_stats)); 54786ee6e18SStephane Eranian read_counter(counter); 54813370a9bSStephane Eranian } 54986ee6e18SStephane Eranian } 55086ee6e18SStephane Eranian 55113370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ts); 55213370a9bSStephane Eranian diff_timespec(&rs, &ts, &ref_time); 55313370a9bSStephane Eranian sprintf(prefix, "%6lu.%09lu%s", rs.tv_sec, rs.tv_nsec, csv_sep); 55413370a9bSStephane Eranian 55513370a9bSStephane Eranian if (num_print_interval == 0 && !csv_output) { 55686ee6e18SStephane Eranian switch (aggr_mode) { 55786ee6e18SStephane Eranian case AGGR_SOCKET: 558410136f5SStephane Eranian fprintf(output, "# time socket cpus counts %*s events\n", unit_width, "unit"); 55986ee6e18SStephane Eranian break; 56012c08a9fSStephane Eranian case AGGR_CORE: 561410136f5SStephane Eranian fprintf(output, "# time core cpus counts %*s events\n", unit_width, "unit"); 56212c08a9fSStephane Eranian break; 56386ee6e18SStephane Eranian case AGGR_NONE: 564410136f5SStephane Eranian fprintf(output, "# time CPU counts %*s events\n", unit_width, "unit"); 56586ee6e18SStephane Eranian break; 56686ee6e18SStephane Eranian case AGGR_GLOBAL: 56786ee6e18SStephane Eranian default: 568410136f5SStephane Eranian fprintf(output, "# time counts %*s events\n", unit_width, "unit"); 56913370a9bSStephane Eranian } 57086ee6e18SStephane Eranian } 57113370a9bSStephane Eranian 57213370a9bSStephane Eranian if (++num_print_interval == 25) 57313370a9bSStephane Eranian num_print_interval = 0; 57413370a9bSStephane Eranian 57586ee6e18SStephane Eranian switch (aggr_mode) { 57612c08a9fSStephane Eranian case AGGR_CORE: 57786ee6e18SStephane Eranian case AGGR_SOCKET: 57886ee6e18SStephane Eranian print_aggr(prefix); 57986ee6e18SStephane Eranian break; 58086ee6e18SStephane Eranian case AGGR_NONE: 5810050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 58213370a9bSStephane Eranian print_counter(counter, prefix); 58386ee6e18SStephane Eranian break; 58486ee6e18SStephane Eranian case AGGR_GLOBAL: 58586ee6e18SStephane Eranian default: 5860050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 58713370a9bSStephane Eranian print_counter_aggr(counter, prefix); 58813370a9bSStephane Eranian } 5892bbf03f1SAndi Kleen 5902bbf03f1SAndi Kleen fflush(output); 59113370a9bSStephane Eranian } 59213370a9bSStephane Eranian 59341191688SAndi Kleen static void handle_initial_delay(void) 59441191688SAndi Kleen { 59541191688SAndi Kleen struct perf_evsel *counter; 59641191688SAndi Kleen 59741191688SAndi Kleen if (initial_delay) { 59841191688SAndi Kleen const int ncpus = cpu_map__nr(evsel_list->cpus), 59941191688SAndi Kleen nthreads = thread_map__nr(evsel_list->threads); 60041191688SAndi Kleen 60141191688SAndi Kleen usleep(initial_delay * 1000); 6020050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 60341191688SAndi Kleen perf_evsel__enable(counter, ncpus, nthreads); 60441191688SAndi Kleen } 60541191688SAndi Kleen } 60641191688SAndi Kleen 607f33cbe72SArnaldo Carvalho de Melo static volatile int workload_exec_errno; 6086af206fdSArnaldo Carvalho de Melo 6096af206fdSArnaldo Carvalho de Melo /* 6106af206fdSArnaldo Carvalho de Melo * perf_evlist__prepare_workload will send a SIGUSR1 6116af206fdSArnaldo Carvalho de Melo * if the fork fails, since we asked by setting its 6126af206fdSArnaldo Carvalho de Melo * want_signal to true. 6136af206fdSArnaldo Carvalho de Melo */ 614f33cbe72SArnaldo Carvalho de Melo static void workload_exec_failed_signal(int signo __maybe_unused, siginfo_t *info, 615f33cbe72SArnaldo Carvalho de Melo void *ucontext __maybe_unused) 6166af206fdSArnaldo Carvalho de Melo { 617f33cbe72SArnaldo Carvalho de Melo workload_exec_errno = info->si_value.sival_int; 6186af206fdSArnaldo Carvalho de Melo } 6196af206fdSArnaldo Carvalho de Melo 620acf28922SNamhyung Kim static int __run_perf_stat(int argc, const char **argv) 62186470930SIngo Molnar { 62256e52e85SArnaldo Carvalho de Melo char msg[512]; 62386470930SIngo Molnar unsigned long long t0, t1; 624cac21425SJiri Olsa struct perf_evsel *counter; 62513370a9bSStephane Eranian struct timespec ts; 626410136f5SStephane Eranian size_t l; 62742202dd5SIngo Molnar int status = 0; 6286be2850eSZhang, Yanmin const bool forks = (argc > 0); 62986470930SIngo Molnar 63013370a9bSStephane Eranian if (interval) { 63113370a9bSStephane Eranian ts.tv_sec = interval / 1000; 63213370a9bSStephane Eranian ts.tv_nsec = (interval % 1000) * 1000000; 63313370a9bSStephane Eranian } else { 63413370a9bSStephane Eranian ts.tv_sec = 1; 63513370a9bSStephane Eranian ts.tv_nsec = 0; 63613370a9bSStephane Eranian } 63713370a9bSStephane Eranian 638acf28922SNamhyung Kim if (forks) { 639735f7e0bSArnaldo Carvalho de Melo if (perf_evlist__prepare_workload(evsel_list, &target, argv, false, 640735f7e0bSArnaldo Carvalho de Melo workload_exec_failed_signal) < 0) { 641acf28922SNamhyung Kim perror("failed to prepare workload"); 642fceda7feSDavid Ahern return -1; 643051ae7f7SPaul Mackerras } 644d20a47e7SNamhyung Kim child_pid = evsel_list->workload.pid; 64560666c63SLiming Wang } 646051ae7f7SPaul Mackerras 6476a4bb04cSJiri Olsa if (group) 64863dab225SArnaldo Carvalho de Melo perf_evlist__set_leader(evsel_list); 6496a4bb04cSJiri Olsa 6500050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 651cac21425SJiri Olsa if (create_perf_stat_counter(counter) < 0) { 652979987a5SDavid Ahern /* 653979987a5SDavid Ahern * PPC returns ENXIO for HW counters until 2.6.37 654979987a5SDavid Ahern * (behavior changed with commit b0a873e). 655979987a5SDavid Ahern */ 65638f6ae1eSAnton Blanchard if (errno == EINVAL || errno == ENOSYS || 657979987a5SDavid Ahern errno == ENOENT || errno == EOPNOTSUPP || 658979987a5SDavid Ahern errno == ENXIO) { 659c63ca0c0SDavid Ahern if (verbose) 660c63ca0c0SDavid Ahern ui__warning("%s event is not supported by the kernel.\n", 6617289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 6622cee77c4SDavid Ahern counter->supported = false; 663ede70290SIngo Molnar continue; 664c63ca0c0SDavid Ahern } 665ede70290SIngo Molnar 66656e52e85SArnaldo Carvalho de Melo perf_evsel__open_strerror(counter, &target, 66756e52e85SArnaldo Carvalho de Melo errno, msg, sizeof(msg)); 66856e52e85SArnaldo Carvalho de Melo ui__error("%s\n", msg); 66956e52e85SArnaldo Carvalho de Melo 670084ab9f8SArnaldo Carvalho de Melo if (child_pid != -1) 671084ab9f8SArnaldo Carvalho de Melo kill(child_pid, SIGTERM); 672fceda7feSDavid Ahern 673084ab9f8SArnaldo Carvalho de Melo return -1; 674084ab9f8SArnaldo Carvalho de Melo } 6752cee77c4SDavid Ahern counter->supported = true; 676410136f5SStephane Eranian 677410136f5SStephane Eranian l = strlen(counter->unit); 678410136f5SStephane Eranian if (l > unit_width) 679410136f5SStephane Eranian unit_width = l; 68048290609SArnaldo Carvalho de Melo } 68186470930SIngo Molnar 6821491a632SArnaldo Carvalho de Melo if (perf_evlist__apply_filters(evsel_list)) { 683cfd748aeSFrederic Weisbecker error("failed to set filter with %d (%s)\n", errno, 684759e612bSMasami Hiramatsu strerror_r(errno, msg, sizeof(msg))); 685cfd748aeSFrederic Weisbecker return -1; 686cfd748aeSFrederic Weisbecker } 687cfd748aeSFrederic Weisbecker 68886470930SIngo Molnar /* 68986470930SIngo Molnar * Enable counters and exec the command: 69086470930SIngo Molnar */ 69186470930SIngo Molnar t0 = rdclock(); 69213370a9bSStephane Eranian clock_gettime(CLOCK_MONOTONIC, &ref_time); 69386470930SIngo Molnar 69460666c63SLiming Wang if (forks) { 695acf28922SNamhyung Kim perf_evlist__start_workload(evsel_list); 69641191688SAndi Kleen handle_initial_delay(); 697acf28922SNamhyung Kim 69813370a9bSStephane Eranian if (interval) { 69913370a9bSStephane Eranian while (!waitpid(child_pid, &status, WNOHANG)) { 70013370a9bSStephane Eranian nanosleep(&ts, NULL); 70113370a9bSStephane Eranian print_interval(); 70213370a9bSStephane Eranian } 70313370a9bSStephane Eranian } 70442202dd5SIngo Molnar wait(&status); 7056af206fdSArnaldo Carvalho de Melo 706f33cbe72SArnaldo Carvalho de Melo if (workload_exec_errno) { 707f33cbe72SArnaldo Carvalho de Melo const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg)); 708f33cbe72SArnaldo Carvalho de Melo pr_err("Workload failed: %s\n", emsg); 7096af206fdSArnaldo Carvalho de Melo return -1; 710f33cbe72SArnaldo Carvalho de Melo } 7116af206fdSArnaldo Carvalho de Melo 71233e49ea7SAndi Kleen if (WIFSIGNALED(status)) 71333e49ea7SAndi Kleen psignal(WTERMSIG(status), argv[0]); 71460666c63SLiming Wang } else { 71541191688SAndi Kleen handle_initial_delay(); 71613370a9bSStephane Eranian while (!done) { 71713370a9bSStephane Eranian nanosleep(&ts, NULL); 71813370a9bSStephane Eranian if (interval) 71913370a9bSStephane Eranian print_interval(); 72013370a9bSStephane Eranian } 72160666c63SLiming Wang } 72286470930SIngo Molnar 72386470930SIngo Molnar t1 = rdclock(); 72486470930SIngo Molnar 7259e9772c4SPeter Zijlstra update_stats(&walltime_nsecs_stats, t1 - t0); 72642202dd5SIngo Molnar 72786ee6e18SStephane Eranian if (aggr_mode == AGGR_GLOBAL) { 7280050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 729c52b12edSArnaldo Carvalho de Melo read_counter_aggr(counter); 7307ae92e74SYan, Zheng perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 731b3a319d5SNamhyung Kim thread_map__nr(evsel_list->threads)); 732c52b12edSArnaldo Carvalho de Melo } 73386ee6e18SStephane Eranian } else { 7340050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 73586ee6e18SStephane Eranian read_counter(counter); 73686ee6e18SStephane Eranian perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1); 73786ee6e18SStephane Eranian } 738c52b12edSArnaldo Carvalho de Melo } 739c52b12edSArnaldo Carvalho de Melo 74042202dd5SIngo Molnar return WEXITSTATUS(status); 74142202dd5SIngo Molnar } 74242202dd5SIngo Molnar 74341cde476SArnaldo Carvalho de Melo static int run_perf_stat(int argc, const char **argv) 7441f16c575SPeter Zijlstra { 7451f16c575SPeter Zijlstra int ret; 7461f16c575SPeter Zijlstra 7471f16c575SPeter Zijlstra if (pre_cmd) { 7481f16c575SPeter Zijlstra ret = system(pre_cmd); 7491f16c575SPeter Zijlstra if (ret) 7501f16c575SPeter Zijlstra return ret; 7511f16c575SPeter Zijlstra } 7521f16c575SPeter Zijlstra 7531f16c575SPeter Zijlstra if (sync_run) 7541f16c575SPeter Zijlstra sync(); 7551f16c575SPeter Zijlstra 7561f16c575SPeter Zijlstra ret = __run_perf_stat(argc, argv); 7571f16c575SPeter Zijlstra if (ret) 7581f16c575SPeter Zijlstra return ret; 7591f16c575SPeter Zijlstra 7601f16c575SPeter Zijlstra if (post_cmd) { 7611f16c575SPeter Zijlstra ret = system(post_cmd); 7621f16c575SPeter Zijlstra if (ret) 7631f16c575SPeter Zijlstra return ret; 7641f16c575SPeter Zijlstra } 7651f16c575SPeter Zijlstra 7661f16c575SPeter Zijlstra return ret; 7671f16c575SPeter Zijlstra } 7681f16c575SPeter Zijlstra 769f99844cbSIngo Molnar static void print_noise_pct(double total, double avg) 770f99844cbSIngo Molnar { 7710007eceaSXiao Guangrong double pct = rel_stddev_stats(total, avg); 772f99844cbSIngo Molnar 7733ae9a34dSZhengyu He if (csv_output) 7744aa9015fSStephane Eranian fprintf(output, "%s%.2f%%", csv_sep, pct); 775a1bca6ccSJim Cromie else if (pct) 7764aa9015fSStephane Eranian fprintf(output, " ( +-%6.2f%% )", pct); 777f99844cbSIngo Molnar } 778f99844cbSIngo Molnar 77969aad6f1SArnaldo Carvalho de Melo static void print_noise(struct perf_evsel *evsel, double avg) 78042202dd5SIngo Molnar { 78169aad6f1SArnaldo Carvalho de Melo struct perf_stat *ps; 78269aad6f1SArnaldo Carvalho de Melo 783849abde9SPeter Zijlstra if (run_count == 1) 784849abde9SPeter Zijlstra return; 785849abde9SPeter Zijlstra 78669aad6f1SArnaldo Carvalho de Melo ps = evsel->priv; 787f99844cbSIngo Molnar print_noise_pct(stddev_stats(&ps->res_stats[0]), avg); 78842202dd5SIngo Molnar } 78942202dd5SIngo Molnar 79012c08a9fSStephane Eranian static void aggr_printout(struct perf_evsel *evsel, int id, int nr) 79142202dd5SIngo Molnar { 79286ee6e18SStephane Eranian switch (aggr_mode) { 79312c08a9fSStephane Eranian case AGGR_CORE: 79412c08a9fSStephane Eranian fprintf(output, "S%d-C%*d%s%*d%s", 79512c08a9fSStephane Eranian cpu_map__id_to_socket(id), 79612c08a9fSStephane Eranian csv_output ? 0 : -8, 79712c08a9fSStephane Eranian cpu_map__id_to_cpu(id), 79812c08a9fSStephane Eranian csv_sep, 79912c08a9fSStephane Eranian csv_output ? 0 : 4, 80012c08a9fSStephane Eranian nr, 80112c08a9fSStephane Eranian csv_sep); 80212c08a9fSStephane Eranian break; 80386ee6e18SStephane Eranian case AGGR_SOCKET: 80486ee6e18SStephane Eranian fprintf(output, "S%*d%s%*d%s", 805d7e7a451SStephane Eranian csv_output ? 0 : -5, 80612c08a9fSStephane Eranian id, 807d7e7a451SStephane Eranian csv_sep, 808d7e7a451SStephane Eranian csv_output ? 0 : 4, 809d7e7a451SStephane Eranian nr, 810d7e7a451SStephane Eranian csv_sep); 81186ee6e18SStephane Eranian break; 81286ee6e18SStephane Eranian case AGGR_NONE: 81386ee6e18SStephane Eranian fprintf(output, "CPU%*d%s", 814d7470b6aSStephane Eranian csv_output ? 0 : -4, 81512c08a9fSStephane Eranian perf_evsel__cpus(evsel)->map[id], csv_sep); 81686ee6e18SStephane Eranian break; 81786ee6e18SStephane Eranian case AGGR_GLOBAL: 81886ee6e18SStephane Eranian default: 81986ee6e18SStephane Eranian break; 82086ee6e18SStephane Eranian } 82186ee6e18SStephane Eranian } 822d7470b6aSStephane Eranian 823da88c7f7SAndi Kleen static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg) 82486ee6e18SStephane Eranian { 82586ee6e18SStephane Eranian double msecs = avg / 1e6; 826410136f5SStephane Eranian const char *fmt_v, *fmt_n; 8274bbe5a61SDavid Ahern char name[25]; 82886ee6e18SStephane Eranian 829410136f5SStephane Eranian fmt_v = csv_output ? "%.6f%s" : "%18.6f%s"; 830410136f5SStephane Eranian fmt_n = csv_output ? "%s" : "%-25s"; 831410136f5SStephane Eranian 832da88c7f7SAndi Kleen aggr_printout(evsel, id, nr); 83386ee6e18SStephane Eranian 8344bbe5a61SDavid Ahern scnprintf(name, sizeof(name), "%s%s", 8354bbe5a61SDavid Ahern perf_evsel__name(evsel), csv_output ? "" : " (msec)"); 836410136f5SStephane Eranian 837410136f5SStephane Eranian fprintf(output, fmt_v, msecs, csv_sep); 838410136f5SStephane Eranian 839410136f5SStephane Eranian if (csv_output) 840410136f5SStephane Eranian fprintf(output, "%s%s", evsel->unit, csv_sep); 841410136f5SStephane Eranian else 842410136f5SStephane Eranian fprintf(output, "%-*s%s", unit_width, evsel->unit, csv_sep); 843410136f5SStephane Eranian 844410136f5SStephane Eranian fprintf(output, fmt_n, name); 845d7470b6aSStephane Eranian 846023695d9SStephane Eranian if (evsel->cgrp) 8474aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, evsel->cgrp->name); 848023695d9SStephane Eranian 84913370a9bSStephane Eranian if (csv_output || interval) 850d7470b6aSStephane Eranian return; 85142202dd5SIngo Molnar 852daec78a0SArnaldo Carvalho de Melo if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK)) 8534aa9015fSStephane Eranian fprintf(output, " # %8.3f CPUs utilized ", 8544aa9015fSStephane Eranian avg / avg_stats(&walltime_nsecs_stats)); 8559dac6a29SNamhyung Kim else 8569dac6a29SNamhyung Kim fprintf(output, " "); 85742202dd5SIngo Molnar } 85842202dd5SIngo Molnar 85915e6392fSNamhyung Kim /* used for get_ratio_color() */ 86015e6392fSNamhyung Kim enum grc_type { 86115e6392fSNamhyung Kim GRC_STALLED_CYCLES_FE, 86215e6392fSNamhyung Kim GRC_STALLED_CYCLES_BE, 86315e6392fSNamhyung Kim GRC_CACHE_MISSES, 86415e6392fSNamhyung Kim GRC_MAX_NR 86515e6392fSNamhyung Kim }; 86615e6392fSNamhyung Kim 86715e6392fSNamhyung Kim static const char *get_ratio_color(enum grc_type type, double ratio) 86815e6392fSNamhyung Kim { 86915e6392fSNamhyung Kim static const double grc_table[GRC_MAX_NR][3] = { 87015e6392fSNamhyung Kim [GRC_STALLED_CYCLES_FE] = { 50.0, 30.0, 10.0 }, 87115e6392fSNamhyung Kim [GRC_STALLED_CYCLES_BE] = { 75.0, 50.0, 20.0 }, 87215e6392fSNamhyung Kim [GRC_CACHE_MISSES] = { 20.0, 10.0, 5.0 }, 87315e6392fSNamhyung Kim }; 87415e6392fSNamhyung Kim const char *color = PERF_COLOR_NORMAL; 87515e6392fSNamhyung Kim 87615e6392fSNamhyung Kim if (ratio > grc_table[type][0]) 87715e6392fSNamhyung Kim color = PERF_COLOR_RED; 87815e6392fSNamhyung Kim else if (ratio > grc_table[type][1]) 87915e6392fSNamhyung Kim color = PERF_COLOR_MAGENTA; 88015e6392fSNamhyung Kim else if (ratio > grc_table[type][2]) 88115e6392fSNamhyung Kim color = PERF_COLOR_YELLOW; 88215e6392fSNamhyung Kim 88315e6392fSNamhyung Kim return color; 88415e6392fSNamhyung Kim } 88515e6392fSNamhyung Kim 8861d037ca1SIrina Tirdea static void print_stalled_cycles_frontend(int cpu, 8871d037ca1SIrina Tirdea struct perf_evsel *evsel 8881d037ca1SIrina Tirdea __maybe_unused, double avg) 889d3d1e86dSIngo Molnar { 890d3d1e86dSIngo Molnar double total, ratio = 0.0; 891d3d1e86dSIngo Molnar const char *color; 892d3d1e86dSIngo Molnar 893d3d1e86dSIngo Molnar total = avg_stats(&runtime_cycles_stats[cpu]); 894d3d1e86dSIngo Molnar 895d3d1e86dSIngo Molnar if (total) 896d3d1e86dSIngo Molnar ratio = avg / total * 100.0; 897d3d1e86dSIngo Molnar 89815e6392fSNamhyung Kim color = get_ratio_color(GRC_STALLED_CYCLES_FE, ratio); 899d3d1e86dSIngo Molnar 9004aa9015fSStephane Eranian fprintf(output, " # "); 9014aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9024aa9015fSStephane Eranian fprintf(output, " frontend cycles idle "); 903d3d1e86dSIngo Molnar } 904d3d1e86dSIngo Molnar 9051d037ca1SIrina Tirdea static void print_stalled_cycles_backend(int cpu, 9061d037ca1SIrina Tirdea struct perf_evsel *evsel 9071d037ca1SIrina Tirdea __maybe_unused, double avg) 908a5d243d0SIngo Molnar { 909a5d243d0SIngo Molnar double total, ratio = 0.0; 910a5d243d0SIngo Molnar const char *color; 911a5d243d0SIngo Molnar 912a5d243d0SIngo Molnar total = avg_stats(&runtime_cycles_stats[cpu]); 913a5d243d0SIngo Molnar 914a5d243d0SIngo Molnar if (total) 915a5d243d0SIngo Molnar ratio = avg / total * 100.0; 916a5d243d0SIngo Molnar 91715e6392fSNamhyung Kim color = get_ratio_color(GRC_STALLED_CYCLES_BE, ratio); 918a5d243d0SIngo Molnar 9194aa9015fSStephane Eranian fprintf(output, " # "); 9204aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9214aa9015fSStephane Eranian fprintf(output, " backend cycles idle "); 922a5d243d0SIngo Molnar } 923a5d243d0SIngo Molnar 9241d037ca1SIrina Tirdea static void print_branch_misses(int cpu, 9251d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9261d037ca1SIrina Tirdea double avg) 927c78df6c1SIngo Molnar { 928c78df6c1SIngo Molnar double total, ratio = 0.0; 929c78df6c1SIngo Molnar const char *color; 930c78df6c1SIngo Molnar 931c78df6c1SIngo Molnar total = avg_stats(&runtime_branches_stats[cpu]); 932c78df6c1SIngo Molnar 933c78df6c1SIngo Molnar if (total) 934c78df6c1SIngo Molnar ratio = avg / total * 100.0; 935c78df6c1SIngo Molnar 93615e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 937c78df6c1SIngo Molnar 9384aa9015fSStephane Eranian fprintf(output, " # "); 9394aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9404aa9015fSStephane Eranian fprintf(output, " of all branches "); 941c78df6c1SIngo Molnar } 942c78df6c1SIngo Molnar 9431d037ca1SIrina Tirdea static void print_l1_dcache_misses(int cpu, 9441d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9451d037ca1SIrina Tirdea double avg) 9468bb6c79fSIngo Molnar { 9478bb6c79fSIngo Molnar double total, ratio = 0.0; 9488bb6c79fSIngo Molnar const char *color; 9498bb6c79fSIngo Molnar 9508bb6c79fSIngo Molnar total = avg_stats(&runtime_l1_dcache_stats[cpu]); 9518bb6c79fSIngo Molnar 9528bb6c79fSIngo Molnar if (total) 9538bb6c79fSIngo Molnar ratio = avg / total * 100.0; 9548bb6c79fSIngo Molnar 95515e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 9568bb6c79fSIngo Molnar 9574aa9015fSStephane Eranian fprintf(output, " # "); 9584aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9594aa9015fSStephane Eranian fprintf(output, " of all L1-dcache hits "); 9608bb6c79fSIngo Molnar } 9618bb6c79fSIngo Molnar 9621d037ca1SIrina Tirdea static void print_l1_icache_misses(int cpu, 9631d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9641d037ca1SIrina Tirdea double avg) 965c3305257SIngo Molnar { 966c3305257SIngo Molnar double total, ratio = 0.0; 967c3305257SIngo Molnar const char *color; 968c3305257SIngo Molnar 969c3305257SIngo Molnar total = avg_stats(&runtime_l1_icache_stats[cpu]); 970c3305257SIngo Molnar 971c3305257SIngo Molnar if (total) 972c3305257SIngo Molnar ratio = avg / total * 100.0; 973c3305257SIngo Molnar 97415e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 975c3305257SIngo Molnar 9764aa9015fSStephane Eranian fprintf(output, " # "); 9774aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9784aa9015fSStephane Eranian fprintf(output, " of all L1-icache hits "); 979c3305257SIngo Molnar } 980c3305257SIngo Molnar 9811d037ca1SIrina Tirdea static void print_dtlb_cache_misses(int cpu, 9821d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 9831d037ca1SIrina Tirdea double avg) 984c3305257SIngo Molnar { 985c3305257SIngo Molnar double total, ratio = 0.0; 986c3305257SIngo Molnar const char *color; 987c3305257SIngo Molnar 988c3305257SIngo Molnar total = avg_stats(&runtime_dtlb_cache_stats[cpu]); 989c3305257SIngo Molnar 990c3305257SIngo Molnar if (total) 991c3305257SIngo Molnar ratio = avg / total * 100.0; 992c3305257SIngo Molnar 99315e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 994c3305257SIngo Molnar 9954aa9015fSStephane Eranian fprintf(output, " # "); 9964aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 9974aa9015fSStephane Eranian fprintf(output, " of all dTLB cache hits "); 998c3305257SIngo Molnar } 999c3305257SIngo Molnar 10001d037ca1SIrina Tirdea static void print_itlb_cache_misses(int cpu, 10011d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 10021d037ca1SIrina Tirdea double avg) 1003c3305257SIngo Molnar { 1004c3305257SIngo Molnar double total, ratio = 0.0; 1005c3305257SIngo Molnar const char *color; 1006c3305257SIngo Molnar 1007c3305257SIngo Molnar total = avg_stats(&runtime_itlb_cache_stats[cpu]); 1008c3305257SIngo Molnar 1009c3305257SIngo Molnar if (total) 1010c3305257SIngo Molnar ratio = avg / total * 100.0; 1011c3305257SIngo Molnar 101215e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 1013c3305257SIngo Molnar 10144aa9015fSStephane Eranian fprintf(output, " # "); 10154aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 10164aa9015fSStephane Eranian fprintf(output, " of all iTLB cache hits "); 1017c3305257SIngo Molnar } 1018c3305257SIngo Molnar 10191d037ca1SIrina Tirdea static void print_ll_cache_misses(int cpu, 10201d037ca1SIrina Tirdea struct perf_evsel *evsel __maybe_unused, 10211d037ca1SIrina Tirdea double avg) 1022c3305257SIngo Molnar { 1023c3305257SIngo Molnar double total, ratio = 0.0; 1024c3305257SIngo Molnar const char *color; 1025c3305257SIngo Molnar 1026c3305257SIngo Molnar total = avg_stats(&runtime_ll_cache_stats[cpu]); 1027c3305257SIngo Molnar 1028c3305257SIngo Molnar if (total) 1029c3305257SIngo Molnar ratio = avg / total * 100.0; 1030c3305257SIngo Molnar 103115e6392fSNamhyung Kim color = get_ratio_color(GRC_CACHE_MISSES, ratio); 1032c3305257SIngo Molnar 10334aa9015fSStephane Eranian fprintf(output, " # "); 10344aa9015fSStephane Eranian color_fprintf(output, color, "%6.2f%%", ratio); 10354aa9015fSStephane Eranian fprintf(output, " of all LL-cache hits "); 1036c3305257SIngo Molnar } 1037c3305257SIngo Molnar 1038da88c7f7SAndi Kleen static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg) 103942202dd5SIngo Molnar { 10404cabc3d1SAndi Kleen double total, ratio = 0.0, total2; 1041410136f5SStephane Eranian double sc = evsel->scale; 1042d7470b6aSStephane Eranian const char *fmt; 1043da88c7f7SAndi Kleen int cpu = cpu_map__id_to_cpu(id); 1044d7470b6aSStephane Eranian 1045410136f5SStephane Eranian if (csv_output) { 1046410136f5SStephane Eranian fmt = sc != 1.0 ? "%.2f%s" : "%.0f%s"; 1047410136f5SStephane Eranian } else { 1048410136f5SStephane Eranian if (big_num) 1049410136f5SStephane Eranian fmt = sc != 1.0 ? "%'18.2f%s" : "%'18.0f%s"; 1050d7470b6aSStephane Eranian else 1051410136f5SStephane Eranian fmt = sc != 1.0 ? "%18.2f%s" : "%18.0f%s"; 1052410136f5SStephane Eranian } 1053f5b4a9c3SStephane Eranian 1054da88c7f7SAndi Kleen aggr_printout(evsel, id, nr); 105586ee6e18SStephane Eranian 105686ee6e18SStephane Eranian if (aggr_mode == AGGR_GLOBAL) 1057f5b4a9c3SStephane Eranian cpu = 0; 1058c7f7fea3SIngo Molnar 1059410136f5SStephane Eranian fprintf(output, fmt, avg, csv_sep); 1060410136f5SStephane Eranian 1061410136f5SStephane Eranian if (evsel->unit) 1062410136f5SStephane Eranian fprintf(output, "%-*s%s", 1063410136f5SStephane Eranian csv_output ? 0 : unit_width, 1064410136f5SStephane Eranian evsel->unit, csv_sep); 1065410136f5SStephane Eranian 1066410136f5SStephane Eranian fprintf(output, "%-*s", csv_output ? 0 : 25, perf_evsel__name(evsel)); 1067d7470b6aSStephane Eranian 1068023695d9SStephane Eranian if (evsel->cgrp) 10694aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, evsel->cgrp->name); 1070023695d9SStephane Eranian 107113370a9bSStephane Eranian if (csv_output || interval) 1072d7470b6aSStephane Eranian return; 107342202dd5SIngo Molnar 1074daec78a0SArnaldo Carvalho de Melo if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) { 1075f5b4a9c3SStephane Eranian total = avg_stats(&runtime_cycles_stats[cpu]); 10763e7a0817SRamkumar Ramachandra if (total) { 1077c7f7fea3SIngo Molnar ratio = avg / total; 10784aa9015fSStephane Eranian fprintf(output, " # %5.2f insns per cycle ", ratio); 10793e7a0817SRamkumar Ramachandra } 1080d3d1e86dSIngo Molnar total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]); 1081d3d1e86dSIngo Molnar total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu])); 1082481f988aSIngo Molnar 1083481f988aSIngo Molnar if (total && avg) { 1084481f988aSIngo Molnar ratio = total / avg; 1085410136f5SStephane Eranian fprintf(output, "\n"); 1086410136f5SStephane Eranian if (aggr_mode == AGGR_NONE) 1087410136f5SStephane Eranian fprintf(output, " "); 1088410136f5SStephane Eranian fprintf(output, " # %5.2f stalled cycles per insn", ratio); 1089481f988aSIngo Molnar } 1090481f988aSIngo Molnar 1091daec78a0SArnaldo Carvalho de Melo } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) && 1092f5b4a9c3SStephane Eranian runtime_branches_stats[cpu].n != 0) { 1093c78df6c1SIngo Molnar print_branch_misses(cpu, evsel, avg); 10948bb6c79fSIngo Molnar } else if ( 10958bb6c79fSIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 10968bb6c79fSIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1D | 10978bb6c79fSIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 10988bb6c79fSIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1099c6264defSIngo Molnar runtime_l1_dcache_stats[cpu].n != 0) { 11008bb6c79fSIngo Molnar print_l1_dcache_misses(cpu, evsel, avg); 1101c3305257SIngo Molnar } else if ( 1102c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1103c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1I | 1104c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1105c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1106c3305257SIngo Molnar runtime_l1_icache_stats[cpu].n != 0) { 1107c3305257SIngo Molnar print_l1_icache_misses(cpu, evsel, avg); 1108c3305257SIngo Molnar } else if ( 1109c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1110c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_DTLB | 1111c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1112c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1113c3305257SIngo Molnar runtime_dtlb_cache_stats[cpu].n != 0) { 1114c3305257SIngo Molnar print_dtlb_cache_misses(cpu, evsel, avg); 1115c3305257SIngo Molnar } else if ( 1116c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1117c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_ITLB | 1118c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1119c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1120c3305257SIngo Molnar runtime_itlb_cache_stats[cpu].n != 0) { 1121c3305257SIngo Molnar print_itlb_cache_misses(cpu, evsel, avg); 1122c3305257SIngo Molnar } else if ( 1123c3305257SIngo Molnar evsel->attr.type == PERF_TYPE_HW_CACHE && 1124c3305257SIngo Molnar evsel->attr.config == ( PERF_COUNT_HW_CACHE_LL | 1125c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_OP_READ) << 8) | 1126c3305257SIngo Molnar ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16)) && 1127c3305257SIngo Molnar runtime_ll_cache_stats[cpu].n != 0) { 1128c3305257SIngo Molnar print_ll_cache_misses(cpu, evsel, avg); 1129d58f4c82SIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES) && 1130d58f4c82SIngo Molnar runtime_cacherefs_stats[cpu].n != 0) { 1131d58f4c82SIngo Molnar total = avg_stats(&runtime_cacherefs_stats[cpu]); 1132d58f4c82SIngo Molnar 1133d58f4c82SIngo Molnar if (total) 1134d58f4c82SIngo Molnar ratio = avg * 100 / total; 1135d58f4c82SIngo Molnar 11364aa9015fSStephane Eranian fprintf(output, " # %8.3f %% of all cache refs ", ratio); 1137d58f4c82SIngo Molnar 1138d3d1e86dSIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) { 1139d3d1e86dSIngo Molnar print_stalled_cycles_frontend(cpu, evsel, avg); 1140129c04cbSIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) { 1141d3d1e86dSIngo Molnar print_stalled_cycles_backend(cpu, evsel, avg); 1142481f988aSIngo Molnar } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) { 1143481f988aSIngo Molnar total = avg_stats(&runtime_nsecs_stats[cpu]); 1144481f988aSIngo Molnar 1145c458fe62SRamkumar Ramachandra if (total) { 1146c458fe62SRamkumar Ramachandra ratio = avg / total; 11474aa9015fSStephane Eranian fprintf(output, " # %8.3f GHz ", ratio); 1148c458fe62SRamkumar Ramachandra } 11494cabc3d1SAndi Kleen } else if (transaction_run && 11504cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX))) { 11514cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_stats[cpu]); 11524cabc3d1SAndi Kleen if (total) 11534cabc3d1SAndi Kleen fprintf(output, 11544cabc3d1SAndi Kleen " # %5.2f%% transactional cycles ", 11554cabc3d1SAndi Kleen 100.0 * (avg / total)); 11564cabc3d1SAndi Kleen } else if (transaction_run && 11574cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_CYCLES_IN_TX_CP))) { 11584cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_stats[cpu]); 11594cabc3d1SAndi Kleen total2 = avg_stats(&runtime_cycles_in_tx_stats[cpu]); 11604cabc3d1SAndi Kleen if (total2 < avg) 11614cabc3d1SAndi Kleen total2 = avg; 11624cabc3d1SAndi Kleen if (total) 11634cabc3d1SAndi Kleen fprintf(output, 11644cabc3d1SAndi Kleen " # %5.2f%% aborted cycles ", 11654cabc3d1SAndi Kleen 100.0 * ((total2-avg) / total)); 11664cabc3d1SAndi Kleen } else if (transaction_run && 11674cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_TRANSACTION_START)) && 11684cabc3d1SAndi Kleen avg > 0 && 11694cabc3d1SAndi Kleen runtime_cycles_in_tx_stats[cpu].n != 0) { 11704cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_in_tx_stats[cpu]); 11714cabc3d1SAndi Kleen 11724cabc3d1SAndi Kleen if (total) 11734cabc3d1SAndi Kleen ratio = total / avg; 11744cabc3d1SAndi Kleen 11754cabc3d1SAndi Kleen fprintf(output, " # %8.0f cycles / transaction ", ratio); 11764cabc3d1SAndi Kleen } else if (transaction_run && 11774cabc3d1SAndi Kleen perf_evsel__cmp(evsel, nth_evsel(T_ELISION_START)) && 11784cabc3d1SAndi Kleen avg > 0 && 11794cabc3d1SAndi Kleen runtime_cycles_in_tx_stats[cpu].n != 0) { 11804cabc3d1SAndi Kleen total = avg_stats(&runtime_cycles_in_tx_stats[cpu]); 11814cabc3d1SAndi Kleen 11824cabc3d1SAndi Kleen if (total) 11834cabc3d1SAndi Kleen ratio = total / avg; 11844cabc3d1SAndi Kleen 11854cabc3d1SAndi Kleen fprintf(output, " # %8.0f cycles / elision ", ratio); 1186481f988aSIngo Molnar } else if (runtime_nsecs_stats[cpu].n != 0) { 11875fde2523SNamhyung Kim char unit = 'M'; 11885fde2523SNamhyung Kim 1189481f988aSIngo Molnar total = avg_stats(&runtime_nsecs_stats[cpu]); 1190481f988aSIngo Molnar 1191481f988aSIngo Molnar if (total) 1192481f988aSIngo Molnar ratio = 1000.0 * avg / total; 11935fde2523SNamhyung Kim if (ratio < 0.001) { 11945fde2523SNamhyung Kim ratio *= 1000; 11955fde2523SNamhyung Kim unit = 'K'; 11965fde2523SNamhyung Kim } 1197481f988aSIngo Molnar 11985fde2523SNamhyung Kim fprintf(output, " # %8.3f %c/sec ", ratio, unit); 1199a5d243d0SIngo Molnar } else { 12004aa9015fSStephane Eranian fprintf(output, " "); 120142202dd5SIngo Molnar } 120242202dd5SIngo Molnar } 120342202dd5SIngo Molnar 120486ee6e18SStephane Eranian static void print_aggr(char *prefix) 1205d7e7a451SStephane Eranian { 1206d7e7a451SStephane Eranian struct perf_evsel *counter; 1207582ec082SStephane Eranian int cpu, cpu2, s, s2, id, nr; 1208410136f5SStephane Eranian double uval; 1209d7e7a451SStephane Eranian u64 ena, run, val; 1210d7e7a451SStephane Eranian 121186ee6e18SStephane Eranian if (!(aggr_map || aggr_get_id)) 1212d7e7a451SStephane Eranian return; 1213d7e7a451SStephane Eranian 121486ee6e18SStephane Eranian for (s = 0; s < aggr_map->nr; s++) { 121586ee6e18SStephane Eranian id = aggr_map->map[s]; 12160050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) { 1217d7e7a451SStephane Eranian val = ena = run = 0; 1218d7e7a451SStephane Eranian nr = 0; 1219d7e7a451SStephane Eranian for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1220582ec082SStephane Eranian cpu2 = perf_evsel__cpus(counter)->map[cpu]; 1221582ec082SStephane Eranian s2 = aggr_get_id(evsel_list->cpus, cpu2); 122286ee6e18SStephane Eranian if (s2 != id) 1223d7e7a451SStephane Eranian continue; 1224d7e7a451SStephane Eranian val += counter->counts->cpu[cpu].val; 1225d7e7a451SStephane Eranian ena += counter->counts->cpu[cpu].ena; 1226d7e7a451SStephane Eranian run += counter->counts->cpu[cpu].run; 1227d7e7a451SStephane Eranian nr++; 1228d7e7a451SStephane Eranian } 1229d7e7a451SStephane Eranian if (prefix) 1230d7e7a451SStephane Eranian fprintf(output, "%s", prefix); 1231d7e7a451SStephane Eranian 1232d7e7a451SStephane Eranian if (run == 0 || ena == 0) { 1233582ec082SStephane Eranian aggr_printout(counter, id, nr); 123486ee6e18SStephane Eranian 1235410136f5SStephane Eranian fprintf(output, "%*s%s", 1236d7e7a451SStephane Eranian csv_output ? 0 : 18, 1237d7e7a451SStephane Eranian counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1238410136f5SStephane Eranian csv_sep); 1239410136f5SStephane Eranian 1240410136f5SStephane Eranian fprintf(output, "%-*s%s", 1241410136f5SStephane Eranian csv_output ? 0 : unit_width, 1242410136f5SStephane Eranian counter->unit, csv_sep); 1243410136f5SStephane Eranian 1244410136f5SStephane Eranian fprintf(output, "%*s", 1245410136f5SStephane Eranian csv_output ? 0 : -25, 1246d7e7a451SStephane Eranian perf_evsel__name(counter)); 124786ee6e18SStephane Eranian 1248d7e7a451SStephane Eranian if (counter->cgrp) 1249d7e7a451SStephane Eranian fprintf(output, "%s%s", 1250d7e7a451SStephane Eranian csv_sep, counter->cgrp->name); 1251d7e7a451SStephane Eranian 1252d7e7a451SStephane Eranian fputc('\n', output); 1253d7e7a451SStephane Eranian continue; 1254d7e7a451SStephane Eranian } 1255410136f5SStephane Eranian uval = val * counter->scale; 1256d7e7a451SStephane Eranian 1257d7e7a451SStephane Eranian if (nsec_counter(counter)) 1258410136f5SStephane Eranian nsec_printout(id, nr, counter, uval); 1259d7e7a451SStephane Eranian else 1260410136f5SStephane Eranian abs_printout(id, nr, counter, uval); 1261d7e7a451SStephane Eranian 1262d7e7a451SStephane Eranian if (!csv_output) { 1263d7e7a451SStephane Eranian print_noise(counter, 1.0); 1264d7e7a451SStephane Eranian 1265d7e7a451SStephane Eranian if (run != ena) 1266d7e7a451SStephane Eranian fprintf(output, " (%.2f%%)", 1267d7e7a451SStephane Eranian 100.0 * run / ena); 1268d7e7a451SStephane Eranian } 1269d7e7a451SStephane Eranian fputc('\n', output); 1270d7e7a451SStephane Eranian } 1271d7e7a451SStephane Eranian } 1272d7e7a451SStephane Eranian } 1273d7e7a451SStephane Eranian 127442202dd5SIngo Molnar /* 127542202dd5SIngo Molnar * Print out the results of a single counter: 1276f5b4a9c3SStephane Eranian * aggregated counts in system-wide mode 127742202dd5SIngo Molnar */ 127813370a9bSStephane Eranian static void print_counter_aggr(struct perf_evsel *counter, char *prefix) 127942202dd5SIngo Molnar { 128069aad6f1SArnaldo Carvalho de Melo struct perf_stat *ps = counter->priv; 128169aad6f1SArnaldo Carvalho de Melo double avg = avg_stats(&ps->res_stats[0]); 1282c52b12edSArnaldo Carvalho de Melo int scaled = counter->counts->scaled; 1283410136f5SStephane Eranian double uval; 128442202dd5SIngo Molnar 128513370a9bSStephane Eranian if (prefix) 128613370a9bSStephane Eranian fprintf(output, "%s", prefix); 128713370a9bSStephane Eranian 128842202dd5SIngo Molnar if (scaled == -1) { 1289410136f5SStephane Eranian fprintf(output, "%*s%s", 1290d7470b6aSStephane Eranian csv_output ? 0 : 18, 12912cee77c4SDavid Ahern counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1292410136f5SStephane Eranian csv_sep); 1293410136f5SStephane Eranian fprintf(output, "%-*s%s", 1294410136f5SStephane Eranian csv_output ? 0 : unit_width, 1295410136f5SStephane Eranian counter->unit, csv_sep); 1296410136f5SStephane Eranian fprintf(output, "%*s", 1297410136f5SStephane Eranian csv_output ? 0 : -25, 12987289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 1299023695d9SStephane Eranian 1300023695d9SStephane Eranian if (counter->cgrp) 13014aa9015fSStephane Eranian fprintf(output, "%s%s", csv_sep, counter->cgrp->name); 1302023695d9SStephane Eranian 13034aa9015fSStephane Eranian fputc('\n', output); 130442202dd5SIngo Molnar return; 130542202dd5SIngo Molnar } 130642202dd5SIngo Molnar 1307410136f5SStephane Eranian uval = avg * counter->scale; 1308410136f5SStephane Eranian 130942202dd5SIngo Molnar if (nsec_counter(counter)) 1310410136f5SStephane Eranian nsec_printout(-1, 0, counter, uval); 131142202dd5SIngo Molnar else 1312410136f5SStephane Eranian abs_printout(-1, 0, counter, uval); 1313849abde9SPeter Zijlstra 13143ae9a34dSZhengyu He print_noise(counter, avg); 13153ae9a34dSZhengyu He 1316d7470b6aSStephane Eranian if (csv_output) { 13174aa9015fSStephane Eranian fputc('\n', output); 1318d7470b6aSStephane Eranian return; 1319d7470b6aSStephane Eranian } 1320d7470b6aSStephane Eranian 1321506d4bc8SPeter Zijlstra if (scaled) { 1322506d4bc8SPeter Zijlstra double avg_enabled, avg_running; 1323506d4bc8SPeter Zijlstra 132469aad6f1SArnaldo Carvalho de Melo avg_enabled = avg_stats(&ps->res_stats[1]); 132569aad6f1SArnaldo Carvalho de Melo avg_running = avg_stats(&ps->res_stats[2]); 1326506d4bc8SPeter Zijlstra 13274aa9015fSStephane Eranian fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled); 1328506d4bc8SPeter Zijlstra } 13294aa9015fSStephane Eranian fprintf(output, "\n"); 133042202dd5SIngo Molnar } 133142202dd5SIngo Molnar 1332f5b4a9c3SStephane Eranian /* 1333f5b4a9c3SStephane Eranian * Print out the results of a single counter: 1334f5b4a9c3SStephane Eranian * does not use aggregated count in system-wide 1335f5b4a9c3SStephane Eranian */ 133613370a9bSStephane Eranian static void print_counter(struct perf_evsel *counter, char *prefix) 1337f5b4a9c3SStephane Eranian { 1338f5b4a9c3SStephane Eranian u64 ena, run, val; 1339410136f5SStephane Eranian double uval; 1340f5b4a9c3SStephane Eranian int cpu; 1341f5b4a9c3SStephane Eranian 13427ae92e74SYan, Zheng for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) { 1343c52b12edSArnaldo Carvalho de Melo val = counter->counts->cpu[cpu].val; 1344c52b12edSArnaldo Carvalho de Melo ena = counter->counts->cpu[cpu].ena; 1345c52b12edSArnaldo Carvalho de Melo run = counter->counts->cpu[cpu].run; 134613370a9bSStephane Eranian 134713370a9bSStephane Eranian if (prefix) 134813370a9bSStephane Eranian fprintf(output, "%s", prefix); 134913370a9bSStephane Eranian 1350f5b4a9c3SStephane Eranian if (run == 0 || ena == 0) { 1351410136f5SStephane Eranian fprintf(output, "CPU%*d%s%*s%s", 1352d7470b6aSStephane Eranian csv_output ? 0 : -4, 13537ae92e74SYan, Zheng perf_evsel__cpus(counter)->map[cpu], csv_sep, 1354d7470b6aSStephane Eranian csv_output ? 0 : 18, 13552cee77c4SDavid Ahern counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED, 1356410136f5SStephane Eranian csv_sep); 1357410136f5SStephane Eranian 1358410136f5SStephane Eranian fprintf(output, "%-*s%s", 1359410136f5SStephane Eranian csv_output ? 0 : unit_width, 1360410136f5SStephane Eranian counter->unit, csv_sep); 1361410136f5SStephane Eranian 1362410136f5SStephane Eranian fprintf(output, "%*s", 1363410136f5SStephane Eranian csv_output ? 0 : -25, 13647289f83cSArnaldo Carvalho de Melo perf_evsel__name(counter)); 1365f5b4a9c3SStephane Eranian 1366023695d9SStephane Eranian if (counter->cgrp) 13674aa9015fSStephane Eranian fprintf(output, "%s%s", 13684aa9015fSStephane Eranian csv_sep, counter->cgrp->name); 1369023695d9SStephane Eranian 13704aa9015fSStephane Eranian fputc('\n', output); 1371f5b4a9c3SStephane Eranian continue; 1372f5b4a9c3SStephane Eranian } 1373f5b4a9c3SStephane Eranian 1374410136f5SStephane Eranian uval = val * counter->scale; 1375410136f5SStephane Eranian 1376f5b4a9c3SStephane Eranian if (nsec_counter(counter)) 1377410136f5SStephane Eranian nsec_printout(cpu, 0, counter, uval); 1378f5b4a9c3SStephane Eranian else 1379410136f5SStephane Eranian abs_printout(cpu, 0, counter, uval); 1380f5b4a9c3SStephane Eranian 1381d7470b6aSStephane Eranian if (!csv_output) { 1382f5b4a9c3SStephane Eranian print_noise(counter, 1.0); 1383f5b4a9c3SStephane Eranian 1384c6264defSIngo Molnar if (run != ena) 13854aa9015fSStephane Eranian fprintf(output, " (%.2f%%)", 13864aa9015fSStephane Eranian 100.0 * run / ena); 1387d7470b6aSStephane Eranian } 13884aa9015fSStephane Eranian fputc('\n', output); 1389f5b4a9c3SStephane Eranian } 1390f5b4a9c3SStephane Eranian } 1391f5b4a9c3SStephane Eranian 139242202dd5SIngo Molnar static void print_stat(int argc, const char **argv) 139342202dd5SIngo Molnar { 139469aad6f1SArnaldo Carvalho de Melo struct perf_evsel *counter; 139569aad6f1SArnaldo Carvalho de Melo int i; 139642202dd5SIngo Molnar 139786470930SIngo Molnar fflush(stdout); 139886470930SIngo Molnar 1399d7470b6aSStephane Eranian if (!csv_output) { 14004aa9015fSStephane Eranian fprintf(output, "\n"); 14014aa9015fSStephane Eranian fprintf(output, " Performance counter stats for "); 140262d3b617SDavid Ahern if (target.system_wide) 140362d3b617SDavid Ahern fprintf(output, "\'system wide"); 140462d3b617SDavid Ahern else if (target.cpu_list) 140562d3b617SDavid Ahern fprintf(output, "\'CPU(s) %s", target.cpu_list); 1406602ad878SArnaldo Carvalho de Melo else if (!target__has_task(&target)) { 14074aa9015fSStephane Eranian fprintf(output, "\'%s", argv[0]); 140886470930SIngo Molnar for (i = 1; i < argc; i++) 14094aa9015fSStephane Eranian fprintf(output, " %s", argv[i]); 141020f946b4SNamhyung Kim } else if (target.pid) 141120f946b4SNamhyung Kim fprintf(output, "process id \'%s", target.pid); 1412d6d901c2SZhang, Yanmin else 141320f946b4SNamhyung Kim fprintf(output, "thread id \'%s", target.tid); 141486470930SIngo Molnar 14154aa9015fSStephane Eranian fprintf(output, "\'"); 141642202dd5SIngo Molnar if (run_count > 1) 14174aa9015fSStephane Eranian fprintf(output, " (%d runs)", run_count); 14184aa9015fSStephane Eranian fprintf(output, ":\n\n"); 1419d7470b6aSStephane Eranian } 142086470930SIngo Molnar 142186ee6e18SStephane Eranian switch (aggr_mode) { 142212c08a9fSStephane Eranian case AGGR_CORE: 142386ee6e18SStephane Eranian case AGGR_SOCKET: 142486ee6e18SStephane Eranian print_aggr(NULL); 142586ee6e18SStephane Eranian break; 142686ee6e18SStephane Eranian case AGGR_GLOBAL: 14270050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 142813370a9bSStephane Eranian print_counter_aggr(counter, NULL); 142986ee6e18SStephane Eranian break; 143086ee6e18SStephane Eranian case AGGR_NONE: 14310050f7aaSArnaldo Carvalho de Melo evlist__for_each(evsel_list, counter) 143286ee6e18SStephane Eranian print_counter(counter, NULL); 143386ee6e18SStephane Eranian break; 143486ee6e18SStephane Eranian default: 143586ee6e18SStephane Eranian break; 1436f5b4a9c3SStephane Eranian } 143786470930SIngo Molnar 1438d7470b6aSStephane Eranian if (!csv_output) { 1439c3305257SIngo Molnar if (!null_run) 14404aa9015fSStephane Eranian fprintf(output, "\n"); 14414aa9015fSStephane Eranian fprintf(output, " %17.9f seconds time elapsed", 1442506d4bc8SPeter Zijlstra avg_stats(&walltime_nsecs_stats)/1e9); 1443566747e6SIngo Molnar if (run_count > 1) { 14444aa9015fSStephane Eranian fprintf(output, " "); 1445f99844cbSIngo Molnar print_noise_pct(stddev_stats(&walltime_nsecs_stats), 1446506d4bc8SPeter Zijlstra avg_stats(&walltime_nsecs_stats)); 1447566747e6SIngo Molnar } 14484aa9015fSStephane Eranian fprintf(output, "\n\n"); 144986470930SIngo Molnar } 1450d7470b6aSStephane Eranian } 145186470930SIngo Molnar 1452f7b7c26eSPeter Zijlstra static volatile int signr = -1; 1453f7b7c26eSPeter Zijlstra 145486470930SIngo Molnar static void skip_signal(int signo) 145586470930SIngo Molnar { 145613370a9bSStephane Eranian if ((child_pid == -1) || interval) 145760666c63SLiming Wang done = 1; 145860666c63SLiming Wang 1459f7b7c26eSPeter Zijlstra signr = signo; 1460d07f0b12SStephane Eranian /* 1461d07f0b12SStephane Eranian * render child_pid harmless 1462d07f0b12SStephane Eranian * won't send SIGTERM to a random 1463d07f0b12SStephane Eranian * process in case of race condition 1464d07f0b12SStephane Eranian * and fast PID recycling 1465d07f0b12SStephane Eranian */ 1466d07f0b12SStephane Eranian child_pid = -1; 1467f7b7c26eSPeter Zijlstra } 1468f7b7c26eSPeter Zijlstra 1469f7b7c26eSPeter Zijlstra static void sig_atexit(void) 1470f7b7c26eSPeter Zijlstra { 1471d07f0b12SStephane Eranian sigset_t set, oset; 1472d07f0b12SStephane Eranian 1473d07f0b12SStephane Eranian /* 1474d07f0b12SStephane Eranian * avoid race condition with SIGCHLD handler 1475d07f0b12SStephane Eranian * in skip_signal() which is modifying child_pid 1476d07f0b12SStephane Eranian * goal is to avoid send SIGTERM to a random 1477d07f0b12SStephane Eranian * process 1478d07f0b12SStephane Eranian */ 1479d07f0b12SStephane Eranian sigemptyset(&set); 1480d07f0b12SStephane Eranian sigaddset(&set, SIGCHLD); 1481d07f0b12SStephane Eranian sigprocmask(SIG_BLOCK, &set, &oset); 1482d07f0b12SStephane Eranian 1483933da83aSChris Wilson if (child_pid != -1) 1484933da83aSChris Wilson kill(child_pid, SIGTERM); 1485933da83aSChris Wilson 1486d07f0b12SStephane Eranian sigprocmask(SIG_SETMASK, &oset, NULL); 1487d07f0b12SStephane Eranian 1488f7b7c26eSPeter Zijlstra if (signr == -1) 1489f7b7c26eSPeter Zijlstra return; 1490f7b7c26eSPeter Zijlstra 1491f7b7c26eSPeter Zijlstra signal(signr, SIG_DFL); 1492f7b7c26eSPeter Zijlstra kill(getpid(), signr); 149386470930SIngo Molnar } 149486470930SIngo Molnar 14951d037ca1SIrina Tirdea static int stat__set_big_num(const struct option *opt __maybe_unused, 14961d037ca1SIrina Tirdea const char *s __maybe_unused, int unset) 1497d7470b6aSStephane Eranian { 1498d7470b6aSStephane Eranian big_num_opt = unset ? 0 : 1; 1499d7470b6aSStephane Eranian return 0; 1500d7470b6aSStephane Eranian } 1501d7470b6aSStephane Eranian 150286ee6e18SStephane Eranian static int perf_stat_init_aggr_mode(void) 150386ee6e18SStephane Eranian { 150486ee6e18SStephane Eranian switch (aggr_mode) { 150586ee6e18SStephane Eranian case AGGR_SOCKET: 150686ee6e18SStephane Eranian if (cpu_map__build_socket_map(evsel_list->cpus, &aggr_map)) { 150786ee6e18SStephane Eranian perror("cannot build socket map"); 150886ee6e18SStephane Eranian return -1; 150986ee6e18SStephane Eranian } 151086ee6e18SStephane Eranian aggr_get_id = cpu_map__get_socket; 151186ee6e18SStephane Eranian break; 151212c08a9fSStephane Eranian case AGGR_CORE: 151312c08a9fSStephane Eranian if (cpu_map__build_core_map(evsel_list->cpus, &aggr_map)) { 151412c08a9fSStephane Eranian perror("cannot build core map"); 151512c08a9fSStephane Eranian return -1; 151612c08a9fSStephane Eranian } 151712c08a9fSStephane Eranian aggr_get_id = cpu_map__get_core; 151812c08a9fSStephane Eranian break; 151986ee6e18SStephane Eranian case AGGR_NONE: 152086ee6e18SStephane Eranian case AGGR_GLOBAL: 152186ee6e18SStephane Eranian default: 152286ee6e18SStephane Eranian break; 152386ee6e18SStephane Eranian } 152486ee6e18SStephane Eranian return 0; 152586ee6e18SStephane Eranian } 152686ee6e18SStephane Eranian 15274cabc3d1SAndi Kleen static int setup_events(const char * const *attrs, unsigned len) 15284cabc3d1SAndi Kleen { 15294cabc3d1SAndi Kleen unsigned i; 15304cabc3d1SAndi Kleen 15314cabc3d1SAndi Kleen for (i = 0; i < len; i++) { 15324cabc3d1SAndi Kleen if (parse_events(evsel_list, attrs[i])) 15334cabc3d1SAndi Kleen return -1; 15344cabc3d1SAndi Kleen } 15354cabc3d1SAndi Kleen return 0; 15364cabc3d1SAndi Kleen } 153786ee6e18SStephane Eranian 15382cba3ffbSIngo Molnar /* 15392cba3ffbSIngo Molnar * Add default attributes, if there were no attributes specified or 15402cba3ffbSIngo Molnar * if -d/--detailed, -d -d or -d -d -d is used: 15412cba3ffbSIngo Molnar */ 15422cba3ffbSIngo Molnar static int add_default_attributes(void) 15432cba3ffbSIngo Molnar { 1544b070a547SArnaldo Carvalho de Melo struct perf_event_attr default_attrs[] = { 1545b070a547SArnaldo Carvalho de Melo 1546b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK }, 1547b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CONTEXT_SWITCHES }, 1548b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_CPU_MIGRATIONS }, 1549b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_PAGE_FAULTS }, 1550b070a547SArnaldo Carvalho de Melo 1551b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_CPU_CYCLES }, 1552b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_FRONTEND }, 1553b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_STALLED_CYCLES_BACKEND }, 1554b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_INSTRUCTIONS }, 1555b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS }, 1556b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_BRANCH_MISSES }, 1557b070a547SArnaldo Carvalho de Melo 1558b070a547SArnaldo Carvalho de Melo }; 1559b070a547SArnaldo Carvalho de Melo 1560b070a547SArnaldo Carvalho de Melo /* 1561b070a547SArnaldo Carvalho de Melo * Detailed stats (-d), covering the L1 and last level data caches: 1562b070a547SArnaldo Carvalho de Melo */ 1563b070a547SArnaldo Carvalho de Melo struct perf_event_attr detailed_attrs[] = { 1564b070a547SArnaldo Carvalho de Melo 1565b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1566b070a547SArnaldo Carvalho de Melo .config = 1567b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1568b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1569b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1570b070a547SArnaldo Carvalho de Melo 1571b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1572b070a547SArnaldo Carvalho de Melo .config = 1573b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1574b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1575b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1576b070a547SArnaldo Carvalho de Melo 1577b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1578b070a547SArnaldo Carvalho de Melo .config = 1579b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 1580b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1581b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1582b070a547SArnaldo Carvalho de Melo 1583b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1584b070a547SArnaldo Carvalho de Melo .config = 1585b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_LL << 0 | 1586b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1587b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1588b070a547SArnaldo Carvalho de Melo }; 1589b070a547SArnaldo Carvalho de Melo 1590b070a547SArnaldo Carvalho de Melo /* 1591b070a547SArnaldo Carvalho de Melo * Very detailed stats (-d -d), covering the instruction cache and the TLB caches: 1592b070a547SArnaldo Carvalho de Melo */ 1593b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_detailed_attrs[] = { 1594b070a547SArnaldo Carvalho de Melo 1595b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1596b070a547SArnaldo Carvalho de Melo .config = 1597b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 1598b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1599b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1600b070a547SArnaldo Carvalho de Melo 1601b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1602b070a547SArnaldo Carvalho de Melo .config = 1603b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1I << 0 | 1604b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1605b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1606b070a547SArnaldo Carvalho de Melo 1607b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1608b070a547SArnaldo Carvalho de Melo .config = 1609b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 1610b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1611b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1612b070a547SArnaldo Carvalho de Melo 1613b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1614b070a547SArnaldo Carvalho de Melo .config = 1615b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_DTLB << 0 | 1616b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1617b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1618b070a547SArnaldo Carvalho de Melo 1619b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1620b070a547SArnaldo Carvalho de Melo .config = 1621b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 1622b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1623b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1624b070a547SArnaldo Carvalho de Melo 1625b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1626b070a547SArnaldo Carvalho de Melo .config = 1627b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_ITLB << 0 | 1628b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_READ << 8) | 1629b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1630b070a547SArnaldo Carvalho de Melo 1631b070a547SArnaldo Carvalho de Melo }; 1632b070a547SArnaldo Carvalho de Melo 1633b070a547SArnaldo Carvalho de Melo /* 1634b070a547SArnaldo Carvalho de Melo * Very, very detailed stats (-d -d -d), adding prefetch events: 1635b070a547SArnaldo Carvalho de Melo */ 1636b070a547SArnaldo Carvalho de Melo struct perf_event_attr very_very_detailed_attrs[] = { 1637b070a547SArnaldo Carvalho de Melo 1638b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1639b070a547SArnaldo Carvalho de Melo .config = 1640b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1641b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 1642b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16) }, 1643b070a547SArnaldo Carvalho de Melo 1644b070a547SArnaldo Carvalho de Melo { .type = PERF_TYPE_HW_CACHE, 1645b070a547SArnaldo Carvalho de Melo .config = 1646b070a547SArnaldo Carvalho de Melo PERF_COUNT_HW_CACHE_L1D << 0 | 1647b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_OP_PREFETCH << 8) | 1648b070a547SArnaldo Carvalho de Melo (PERF_COUNT_HW_CACHE_RESULT_MISS << 16) }, 1649b070a547SArnaldo Carvalho de Melo }; 1650b070a547SArnaldo Carvalho de Melo 16512cba3ffbSIngo Molnar /* Set attrs if no event is selected and !null_run: */ 16522cba3ffbSIngo Molnar if (null_run) 16532cba3ffbSIngo Molnar return 0; 16542cba3ffbSIngo Molnar 16554cabc3d1SAndi Kleen if (transaction_run) { 16564cabc3d1SAndi Kleen int err; 16574cabc3d1SAndi Kleen if (pmu_have_event("cpu", "cycles-ct") && 16584cabc3d1SAndi Kleen pmu_have_event("cpu", "el-start")) 16594cabc3d1SAndi Kleen err = setup_events(transaction_attrs, 16604cabc3d1SAndi Kleen ARRAY_SIZE(transaction_attrs)); 16614cabc3d1SAndi Kleen else 16624cabc3d1SAndi Kleen err = setup_events(transaction_limited_attrs, 16634cabc3d1SAndi Kleen ARRAY_SIZE(transaction_limited_attrs)); 16644cabc3d1SAndi Kleen if (err < 0) { 16654cabc3d1SAndi Kleen fprintf(stderr, "Cannot set up transaction events\n"); 16664cabc3d1SAndi Kleen return -1; 16674cabc3d1SAndi Kleen } 16684cabc3d1SAndi Kleen return 0; 16694cabc3d1SAndi Kleen } 16704cabc3d1SAndi Kleen 16712cba3ffbSIngo Molnar if (!evsel_list->nr_entries) { 167279695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, default_attrs) < 0) 16732cba3ffbSIngo Molnar return -1; 16742cba3ffbSIngo Molnar } 16752cba3ffbSIngo Molnar 16762cba3ffbSIngo Molnar /* Detailed events get appended to the event list: */ 16772cba3ffbSIngo Molnar 16782cba3ffbSIngo Molnar if (detailed_run < 1) 16792cba3ffbSIngo Molnar return 0; 16802cba3ffbSIngo Molnar 16812cba3ffbSIngo Molnar /* Append detailed run extra attributes: */ 168279695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, detailed_attrs) < 0) 16832cba3ffbSIngo Molnar return -1; 16842cba3ffbSIngo Molnar 16852cba3ffbSIngo Molnar if (detailed_run < 2) 16862cba3ffbSIngo Molnar return 0; 16872cba3ffbSIngo Molnar 16882cba3ffbSIngo Molnar /* Append very detailed run extra attributes: */ 168979695e1bSArnaldo Carvalho de Melo if (perf_evlist__add_default_attrs(evsel_list, very_detailed_attrs) < 0) 16902cba3ffbSIngo Molnar return -1; 16912cba3ffbSIngo Molnar 16922cba3ffbSIngo Molnar if (detailed_run < 3) 16932cba3ffbSIngo Molnar return 0; 16942cba3ffbSIngo Molnar 16952cba3ffbSIngo Molnar /* Append very, very detailed run extra attributes: */ 169679695e1bSArnaldo Carvalho de Melo return perf_evlist__add_default_attrs(evsel_list, very_very_detailed_attrs); 16972cba3ffbSIngo Molnar } 16982cba3ffbSIngo Molnar 16991d037ca1SIrina Tirdea int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused) 170086470930SIngo Molnar { 17011f16c575SPeter Zijlstra bool append_file = false; 1702b070a547SArnaldo Carvalho de Melo int output_fd = 0; 1703b070a547SArnaldo Carvalho de Melo const char *output_name = NULL; 1704b070a547SArnaldo Carvalho de Melo const struct option options[] = { 17054cabc3d1SAndi Kleen OPT_BOOLEAN('T', "transaction", &transaction_run, 17064cabc3d1SAndi Kleen "hardware transaction statistics"), 1707b070a547SArnaldo Carvalho de Melo OPT_CALLBACK('e', "event", &evsel_list, "event", 1708b070a547SArnaldo Carvalho de Melo "event selector. use 'perf list' to list available events", 1709b070a547SArnaldo Carvalho de Melo parse_events_option), 1710b070a547SArnaldo Carvalho de Melo OPT_CALLBACK(0, "filter", &evsel_list, "filter", 1711b070a547SArnaldo Carvalho de Melo "event filter", parse_filter), 1712b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('i', "no-inherit", &no_inherit, 1713b070a547SArnaldo Carvalho de Melo "child tasks do not inherit counters"), 1714b070a547SArnaldo Carvalho de Melo OPT_STRING('p', "pid", &target.pid, "pid", 1715b070a547SArnaldo Carvalho de Melo "stat events on existing process id"), 1716b070a547SArnaldo Carvalho de Melo OPT_STRING('t', "tid", &target.tid, "tid", 1717b070a547SArnaldo Carvalho de Melo "stat events on existing thread id"), 1718b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('a', "all-cpus", &target.system_wide, 1719b070a547SArnaldo Carvalho de Melo "system-wide collection from all CPUs"), 1720b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('g', "group", &group, 1721b070a547SArnaldo Carvalho de Melo "put the counters into a counter group"), 1722b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('c', "scale", &scale, "scale/normalize counters"), 1723b070a547SArnaldo Carvalho de Melo OPT_INCR('v', "verbose", &verbose, 1724b070a547SArnaldo Carvalho de Melo "be more verbose (show counter open errors, etc)"), 1725b070a547SArnaldo Carvalho de Melo OPT_INTEGER('r', "repeat", &run_count, 1726a7e191c3SFrederik Deweerdt "repeat command and print average + stddev (max: 100, forever: 0)"), 1727b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('n', "null", &null_run, 1728b070a547SArnaldo Carvalho de Melo "null run - dont start any counters"), 1729b070a547SArnaldo Carvalho de Melo OPT_INCR('d', "detailed", &detailed_run, 1730b070a547SArnaldo Carvalho de Melo "detailed run - start a lot of events"), 1731b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN('S', "sync", &sync_run, 1732b070a547SArnaldo Carvalho de Melo "call sync() before starting a run"), 1733b070a547SArnaldo Carvalho de Melo OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 1734b070a547SArnaldo Carvalho de Melo "print large numbers with thousands\' separators", 1735b070a547SArnaldo Carvalho de Melo stat__set_big_num), 1736b070a547SArnaldo Carvalho de Melo OPT_STRING('C', "cpu", &target.cpu_list, "cpu", 1737b070a547SArnaldo Carvalho de Melo "list of cpus to monitor in system-wide"), 173886ee6e18SStephane Eranian OPT_SET_UINT('A', "no-aggr", &aggr_mode, 173986ee6e18SStephane Eranian "disable CPU count aggregation", AGGR_NONE), 1740b070a547SArnaldo Carvalho de Melo OPT_STRING('x', "field-separator", &csv_sep, "separator", 1741b070a547SArnaldo Carvalho de Melo "print counts with custom separator"), 1742b070a547SArnaldo Carvalho de Melo OPT_CALLBACK('G', "cgroup", &evsel_list, "name", 1743b070a547SArnaldo Carvalho de Melo "monitor event in cgroup name only", parse_cgroups), 1744b070a547SArnaldo Carvalho de Melo OPT_STRING('o', "output", &output_name, "file", "output file name"), 1745b070a547SArnaldo Carvalho de Melo OPT_BOOLEAN(0, "append", &append_file, "append to the output file"), 1746b070a547SArnaldo Carvalho de Melo OPT_INTEGER(0, "log-fd", &output_fd, 1747b070a547SArnaldo Carvalho de Melo "log output to fd, instead of stderr"), 17481f16c575SPeter Zijlstra OPT_STRING(0, "pre", &pre_cmd, "command", 17491f16c575SPeter Zijlstra "command to run prior to the measured command"), 17501f16c575SPeter Zijlstra OPT_STRING(0, "post", &post_cmd, "command", 17511f16c575SPeter Zijlstra "command to run after to the measured command"), 175213370a9bSStephane Eranian OPT_UINTEGER('I', "interval-print", &interval, 175313370a9bSStephane Eranian "print counts at regular interval in ms (>= 100)"), 1754d4304958SStephane Eranian OPT_SET_UINT(0, "per-socket", &aggr_mode, 175586ee6e18SStephane Eranian "aggregate counts per processor socket", AGGR_SOCKET), 175612c08a9fSStephane Eranian OPT_SET_UINT(0, "per-core", &aggr_mode, 175712c08a9fSStephane Eranian "aggregate counts per physical processor core", AGGR_CORE), 175841191688SAndi Kleen OPT_UINTEGER('D', "delay", &initial_delay, 175941191688SAndi Kleen "ms to wait before starting measurement after program start"), 1760b070a547SArnaldo Carvalho de Melo OPT_END() 1761b070a547SArnaldo Carvalho de Melo }; 1762b070a547SArnaldo Carvalho de Melo const char * const stat_usage[] = { 1763b070a547SArnaldo Carvalho de Melo "perf stat [<options>] [<command>]", 1764b070a547SArnaldo Carvalho de Melo NULL 1765b070a547SArnaldo Carvalho de Melo }; 1766cc03c542SNamhyung Kim int status = -EINVAL, run_idx; 17674aa9015fSStephane Eranian const char *mode; 176842202dd5SIngo Molnar 17695af52b51SStephane Eranian setlocale(LC_ALL, ""); 17705af52b51SStephane Eranian 1771334fe7a3SNamhyung Kim evsel_list = perf_evlist__new(); 1772361c99a6SArnaldo Carvalho de Melo if (evsel_list == NULL) 1773361c99a6SArnaldo Carvalho de Melo return -ENOMEM; 1774361c99a6SArnaldo Carvalho de Melo 1775a0541234SAnton Blanchard argc = parse_options(argc, argv, options, stat_usage, 1776a0541234SAnton Blanchard PARSE_OPT_STOP_AT_NON_OPTION); 1777d7470b6aSStephane Eranian 17784aa9015fSStephane Eranian output = stderr; 17794aa9015fSStephane Eranian if (output_name && strcmp(output_name, "-")) 17804aa9015fSStephane Eranian output = NULL; 17814aa9015fSStephane Eranian 178256f3bae7SJim Cromie if (output_name && output_fd) { 178356f3bae7SJim Cromie fprintf(stderr, "cannot use both --output and --log-fd\n"); 1784cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "o", 1); 1785cc03c542SNamhyung Kim parse_options_usage(NULL, options, "log-fd", 0); 1786cc03c542SNamhyung Kim goto out; 178756f3bae7SJim Cromie } 1788fc3e4d07SStephane Eranian 1789fc3e4d07SStephane Eranian if (output_fd < 0) { 1790fc3e4d07SStephane Eranian fprintf(stderr, "argument to --log-fd must be a > 0\n"); 1791cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "log-fd", 0); 1792cc03c542SNamhyung Kim goto out; 1793fc3e4d07SStephane Eranian } 1794fc3e4d07SStephane Eranian 17954aa9015fSStephane Eranian if (!output) { 17964aa9015fSStephane Eranian struct timespec tm; 17974aa9015fSStephane Eranian mode = append_file ? "a" : "w"; 17984aa9015fSStephane Eranian 17994aa9015fSStephane Eranian output = fopen(output_name, mode); 18004aa9015fSStephane Eranian if (!output) { 18014aa9015fSStephane Eranian perror("failed to create output file"); 1802fceda7feSDavid Ahern return -1; 18034aa9015fSStephane Eranian } 18044aa9015fSStephane Eranian clock_gettime(CLOCK_REALTIME, &tm); 18054aa9015fSStephane Eranian fprintf(output, "# started on %s\n", ctime(&tm.tv_sec)); 1806fc3e4d07SStephane Eranian } else if (output_fd > 0) { 180756f3bae7SJim Cromie mode = append_file ? "a" : "w"; 180856f3bae7SJim Cromie output = fdopen(output_fd, mode); 180956f3bae7SJim Cromie if (!output) { 181056f3bae7SJim Cromie perror("Failed opening logfd"); 181156f3bae7SJim Cromie return -errno; 181256f3bae7SJim Cromie } 18134aa9015fSStephane Eranian } 18144aa9015fSStephane Eranian 1815d4ffd04dSJim Cromie if (csv_sep) { 1816d7470b6aSStephane Eranian csv_output = true; 1817d4ffd04dSJim Cromie if (!strcmp(csv_sep, "\\t")) 1818d4ffd04dSJim Cromie csv_sep = "\t"; 1819d4ffd04dSJim Cromie } else 1820d7470b6aSStephane Eranian csv_sep = DEFAULT_SEPARATOR; 1821d7470b6aSStephane Eranian 1822d7470b6aSStephane Eranian /* 1823d7470b6aSStephane Eranian * let the spreadsheet do the pretty-printing 1824d7470b6aSStephane Eranian */ 1825d7470b6aSStephane Eranian if (csv_output) { 182661a9f324SJim Cromie /* User explicitly passed -B? */ 1827d7470b6aSStephane Eranian if (big_num_opt == 1) { 1828d7470b6aSStephane Eranian fprintf(stderr, "-B option not supported with -x\n"); 1829cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "B", 1); 1830cc03c542SNamhyung Kim parse_options_usage(NULL, options, "x", 1); 1831cc03c542SNamhyung Kim goto out; 1832d7470b6aSStephane Eranian } else /* Nope, so disable big number formatting */ 1833d7470b6aSStephane Eranian big_num = false; 1834d7470b6aSStephane Eranian } else if (big_num_opt == 0) /* User passed --no-big-num */ 1835d7470b6aSStephane Eranian big_num = false; 1836d7470b6aSStephane Eranian 1837602ad878SArnaldo Carvalho de Melo if (!argc && target__none(&target)) 183886470930SIngo Molnar usage_with_options(stat_usage, options); 1839ac3063bdSDavid Ahern 1840a7e191c3SFrederik Deweerdt if (run_count < 0) { 1841cc03c542SNamhyung Kim pr_err("Run count must be a positive number\n"); 1842cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "r", 1); 1843cc03c542SNamhyung Kim goto out; 1844a7e191c3SFrederik Deweerdt } else if (run_count == 0) { 1845a7e191c3SFrederik Deweerdt forever = true; 1846a7e191c3SFrederik Deweerdt run_count = 1; 1847a7e191c3SFrederik Deweerdt } 184886470930SIngo Molnar 1849023695d9SStephane Eranian /* no_aggr, cgroup are for system-wide only */ 1850602ad878SArnaldo Carvalho de Melo if ((aggr_mode != AGGR_GLOBAL || nr_cgroups) && 1851602ad878SArnaldo Carvalho de Melo !target__has_cpu(&target)) { 1852023695d9SStephane Eranian fprintf(stderr, "both cgroup and no-aggregation " 1853023695d9SStephane Eranian "modes only available in system-wide mode\n"); 1854023695d9SStephane Eranian 1855cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "G", 1); 1856cc03c542SNamhyung Kim parse_options_usage(NULL, options, "A", 1); 1857cc03c542SNamhyung Kim parse_options_usage(NULL, options, "a", 1); 1858cc03c542SNamhyung Kim goto out; 1859d7e7a451SStephane Eranian } 1860d7e7a451SStephane Eranian 18612cba3ffbSIngo Molnar if (add_default_attributes()) 1862c6264defSIngo Molnar goto out; 186386470930SIngo Molnar 1864602ad878SArnaldo Carvalho de Melo target__validate(&target); 18655c98d466SArnaldo Carvalho de Melo 186677a6f014SNamhyung Kim if (perf_evlist__create_maps(evsel_list, &target) < 0) { 1867602ad878SArnaldo Carvalho de Melo if (target__has_task(&target)) { 18685c98d466SArnaldo Carvalho de Melo pr_err("Problems finding threads of monitor\n"); 1869cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "p", 1); 1870cc03c542SNamhyung Kim parse_options_usage(NULL, options, "t", 1); 1871602ad878SArnaldo Carvalho de Melo } else if (target__has_cpu(&target)) { 187260d567e2SArnaldo Carvalho de Melo perror("failed to parse CPUs map"); 1873cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "C", 1); 1874cc03c542SNamhyung Kim parse_options_usage(NULL, options, "a", 1); 1875cc03c542SNamhyung Kim } 1876cc03c542SNamhyung Kim goto out; 187760d567e2SArnaldo Carvalho de Melo } 187813370a9bSStephane Eranian if (interval && interval < 100) { 187913370a9bSStephane Eranian pr_err("print interval must be >= 100ms\n"); 1880cc03c542SNamhyung Kim parse_options_usage(stat_usage, options, "I", 1); 188103ad9747SArnaldo Carvalho de Melo goto out; 188213370a9bSStephane Eranian } 1883c45c6ea2SStephane Eranian 1884d134ffb9SArnaldo Carvalho de Melo if (perf_evlist__alloc_stats(evsel_list, interval)) 188503ad9747SArnaldo Carvalho de Melo goto out; 1886d6d901c2SZhang, Yanmin 188786ee6e18SStephane Eranian if (perf_stat_init_aggr_mode()) 188803ad9747SArnaldo Carvalho de Melo goto out; 188986ee6e18SStephane Eranian 189086470930SIngo Molnar /* 189186470930SIngo Molnar * We dont want to block the signals - that would cause 189286470930SIngo Molnar * child tasks to inherit that and Ctrl-C would not work. 189386470930SIngo Molnar * What we want is for Ctrl-C to work in the exec()-ed 189486470930SIngo Molnar * task, but being ignored by perf stat itself: 189586470930SIngo Molnar */ 1896f7b7c26eSPeter Zijlstra atexit(sig_atexit); 1897a7e191c3SFrederik Deweerdt if (!forever) 189886470930SIngo Molnar signal(SIGINT, skip_signal); 189913370a9bSStephane Eranian signal(SIGCHLD, skip_signal); 190086470930SIngo Molnar signal(SIGALRM, skip_signal); 190186470930SIngo Molnar signal(SIGABRT, skip_signal); 190286470930SIngo Molnar 190342202dd5SIngo Molnar status = 0; 1904a7e191c3SFrederik Deweerdt for (run_idx = 0; forever || run_idx < run_count; run_idx++) { 190542202dd5SIngo Molnar if (run_count != 1 && verbose) 19064aa9015fSStephane Eranian fprintf(output, "[ perf stat: executing run #%d ... ]\n", 19074aa9015fSStephane Eranian run_idx + 1); 1908f9cef0a9SIngo Molnar 190942202dd5SIngo Molnar status = run_perf_stat(argc, argv); 1910a7e191c3SFrederik Deweerdt if (forever && status != -1) { 1911a7e191c3SFrederik Deweerdt print_stat(argc, argv); 1912d134ffb9SArnaldo Carvalho de Melo perf_stat__reset_stats(evsel_list); 1913a7e191c3SFrederik Deweerdt } 191442202dd5SIngo Molnar } 191542202dd5SIngo Molnar 1916a7e191c3SFrederik Deweerdt if (!forever && status != -1 && !interval) 191742202dd5SIngo Molnar print_stat(argc, argv); 1918d134ffb9SArnaldo Carvalho de Melo 1919d134ffb9SArnaldo Carvalho de Melo perf_evlist__free_stats(evsel_list); 19200015e2e1SArnaldo Carvalho de Melo out: 19210015e2e1SArnaldo Carvalho de Melo perf_evlist__delete(evsel_list); 192242202dd5SIngo Molnar return status; 192386470930SIngo Molnar } 1924