/* * perf stat: /usr/bin/time -alike performance counter statistics utility It summarizes the counter events of all tasks (and child tasks), covering all CPUs that the command (or workload) executes on. It only counts the per-task events of the workload started, independent of how many other tasks run on those CPUs. Sample output: $ perf stat -e 1 -e 3 -e 5 ls -lR /usr/include/ >/dev/null Performance counter stats for 'ls': 163516953 instructions 2295 cache-misses 2855182 branch-misses * * Copyright (C) 2008, Red Hat Inc, Ingo Molnar * * Improvements and fixes by: * * Arjan van de Ven * Yanmin Zhang * Wu Fengguang * Mike Galbraith * Paul Mackerras * * Released under the GPL v2. (and only v2, not any later version) */ #include "perf.h" #include "builtin.h" #include "util/util.h" #include "util/parse-options.h" #include "util/parse-events.h" #include static int system_wide = 0; static int inherit = 1; static __u64 default_event_id[MAX_COUNTERS] = { EID(PERF_TYPE_SOFTWARE, PERF_COUNT_TASK_CLOCK), EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CONTEXT_SWITCHES), EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_MIGRATIONS), EID(PERF_TYPE_SOFTWARE, PERF_COUNT_PAGE_FAULTS), EID(PERF_TYPE_HARDWARE, PERF_COUNT_CPU_CYCLES), EID(PERF_TYPE_HARDWARE, PERF_COUNT_INSTRUCTIONS), EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_REFERENCES), EID(PERF_TYPE_HARDWARE, PERF_COUNT_CACHE_MISSES), }; static int default_interval = 100000; static int event_count[MAX_COUNTERS]; static int fd[MAX_NR_CPUS][MAX_COUNTERS]; static int target_pid = -1; static int nr_cpus = 0; static unsigned int page_size; static int scale = 1; static const unsigned int default_count[] = { 1000000, 1000000, 10000, 10000, 1000000, 10000, }; static __u64 event_res[MAX_COUNTERS][3]; static __u64 event_scaled[MAX_COUNTERS]; static __u64 runtime_nsecs; static __u64 walltime_nsecs; static void create_perfstat_counter(int counter) { struct perf_counter_hw_event hw_event; memset(&hw_event, 0, sizeof(hw_event)); hw_event.config = event_id[counter]; hw_event.record_type = 0; hw_event.nmi = 1; hw_event.exclude_kernel = event_mask[counter] & EVENT_MASK_KERNEL; hw_event.exclude_user = event_mask[counter] & EVENT_MASK_USER; if (scale) hw_event.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_TOTAL_TIME_RUNNING; if (system_wide) { int cpu; for (cpu = 0; cpu < nr_cpus; cpu ++) { fd[cpu][counter] = sys_perf_counter_open(&hw_event, -1, cpu, -1, 0); if (fd[cpu][counter] < 0) { printf("perfstat error: syscall returned with %d (%s)\n", fd[cpu][counter], strerror(errno)); exit(-1); } } } else { hw_event.inherit = inherit; hw_event.disabled = 1; fd[0][counter] = sys_perf_counter_open(&hw_event, 0, -1, -1, 0); if (fd[0][counter] < 0) { printf("perfstat error: syscall returned with %d (%s)\n", fd[0][counter], strerror(errno)); exit(-1); } } } /* * Does the counter have nsecs as a unit? */ static inline int nsec_counter(int counter) { if (event_id[counter] == EID(PERF_TYPE_SOFTWARE, PERF_COUNT_CPU_CLOCK)) return 1; if (event_id[counter] == EID(PERF_TYPE_SOFTWARE, PERF_COUNT_TASK_CLOCK)) return 1; return 0; } /* * Read out the results of a single counter: */ static void read_counter(int counter) { __u64 *count, single_count[3]; ssize_t res; int cpu, nv; int scaled; count = event_res[counter]; count[0] = count[1] = count[2] = 0; nv = scale ? 3 : 1; for (cpu = 0; cpu < nr_cpus; cpu ++) { res = read(fd[cpu][counter], single_count, nv * sizeof(__u64)); assert(res == nv * sizeof(__u64)); count[0] += single_count[0]; if (scale) { count[1] += single_count[1]; count[2] += single_count[2]; } } scaled = 0; if (scale) { if (count[2] == 0) { event_scaled[counter] = -1; count[0] = 0; return; } if (count[2] < count[1]) { event_scaled[counter] = 1; count[0] = (unsigned long long) ((double)count[0] * count[1] / count[2] + 0.5); } } /* * Save the full runtime - to allow normalization during printout: */ if (event_id[counter] == EID(PERF_TYPE_SOFTWARE, PERF_COUNT_TASK_CLOCK)) runtime_nsecs = count[0]; } /* * Print out the results of a single counter: */ static void print_counter(int counter) { __u64 *count; int scaled; count = event_res[counter]; scaled = event_scaled[counter]; if (scaled == -1) { fprintf(stderr, " %14s %-20s\n", "", event_name(counter)); return; } if (nsec_counter(counter)) { double msecs = (double)count[0] / 1000000; fprintf(stderr, " %14.6f %-20s", msecs, event_name(counter)); if (event_id[counter] == EID(PERF_TYPE_SOFTWARE, PERF_COUNT_TASK_CLOCK)) { fprintf(stderr, " # %11.3f CPU utilization factor", (double)count[0] / (double)walltime_nsecs); } } else { fprintf(stderr, " %14Ld %-20s", count[0], event_name(counter)); if (runtime_nsecs) fprintf(stderr, " # %11.3f M/sec", (double)count[0]/runtime_nsecs*1000.0); } if (scaled) fprintf(stderr, " (scaled from %.2f%%)", (double) count[2] / count[1] * 100); fprintf(stderr, "\n"); } static int do_perfstat(int argc, const char **argv) { unsigned long long t0, t1; int counter; int status; int pid; if (!system_wide) nr_cpus = 1; for (counter = 0; counter < nr_counters; counter++) create_perfstat_counter(counter); /* * Enable counters and exec the command: */ t0 = rdclock(); prctl(PR_TASK_PERF_COUNTERS_ENABLE); if ((pid = fork()) < 0) perror("failed to fork"); if (!pid) { if (execvp(argv[0], (char **)argv)) { perror(argv[0]); exit(-1); } } while (wait(&status) >= 0) ; prctl(PR_TASK_PERF_COUNTERS_DISABLE); t1 = rdclock(); walltime_nsecs = t1 - t0; fflush(stdout); fprintf(stderr, "\n"); fprintf(stderr, " Performance counter stats for \'%s\':\n", argv[0]); fprintf(stderr, "\n"); for (counter = 0; counter < nr_counters; counter++) read_counter(counter); for (counter = 0; counter < nr_counters; counter++) print_counter(counter); fprintf(stderr, "\n"); fprintf(stderr, " Wall-clock time elapsed: %12.6f msecs\n", (double)(t1-t0)/1e6); fprintf(stderr, "\n"); return 0; } static void skip_signal(int signo) { } static const char * const stat_usage[] = { "perf stat [] ", NULL }; static char events_help_msg[EVENTS_HELP_MAX]; static const struct option options[] = { OPT_CALLBACK('e', "event", NULL, "event", events_help_msg, parse_events), OPT_INTEGER('c', "count", &default_interval, "event period to sample"), OPT_BOOLEAN('i', "inherit", &inherit, "child tasks inherit counters"), OPT_INTEGER('p', "pid", &target_pid, "stat events on existing pid"), OPT_BOOLEAN('a', "all-cpus", &system_wide, "system-wide collection from all CPUs"), OPT_BOOLEAN('l', "scale", &scale, "scale/normalize counters"), OPT_END() }; int cmd_stat(int argc, const char **argv, const char *prefix) { int counter; page_size = sysconf(_SC_PAGE_SIZE); create_events_help(events_help_msg); memcpy(event_id, default_event_id, sizeof(default_event_id)); argc = parse_options(argc, argv, options, stat_usage, 0); if (!argc) usage_with_options(stat_usage, options); if (!nr_counters) { nr_counters = 8; } for (counter = 0; counter < nr_counters; counter++) { if (event_count[counter]) continue; event_count[counter] = default_interval; } nr_cpus = sysconf(_SC_NPROCESSORS_ONLN); assert(nr_cpus <= MAX_NR_CPUS); assert(nr_cpus >= 0); /* * We dont want to block the signals - that would cause * child tasks to inherit that and Ctrl-C would not work. * What we want is for Ctrl-C to work in the exec()-ed * task, but being ignored by perf stat itself: */ signal(SIGINT, skip_signal); signal(SIGALRM, skip_signal); signal(SIGABRT, skip_signal); return do_perfstat(argc, argv); }