| /* |
| * Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| /* |
| * A very simple perf program to periodically print the performance |
| * counter reqested on the command line to standard out at the rate |
| * specified. |
| * |
| * This is valuable for showing the output in a simple plot or |
| * exporting the counter data for post processing. No attempt |
| * to process the data is made. |
| * |
| * Scaling is not supported, use only as many counters as are |
| * provided by the hardware. |
| * |
| * Math functions are support to combine counter results by using |
| * the -m flag. |
| * |
| * The -r -w flags supports user signalling for input. This assumes |
| * that a pipe/fifo is needed so the -rw cmd line arg is a string |
| * that is the name of the named pipe to open for read/write. User |
| * sends data on the read pipe to the process to collect a sample. |
| * Commands are also supported on the pipe. |
| * |
| */ |
| |
| #include "perf.h" |
| #include "builtin.h" |
| #include "util/util.h" |
| #include "util/parse-options.h" |
| #include "util/parse-events.h" |
| #include "util/event.h" |
| #include "util/evsel.h" |
| #include "util/evlist.h" |
| #include "util/debug.h" |
| #include "util/header.h" |
| #include "util/cpumap.h" |
| #include "util/thread.h" |
| #include <signal.h> |
| #include <sys/types.h> |
| |
| #define PERF_PERIODIC_ERROR -1 |
| |
| /* number of pieces of data on each read. */ |
| #define DATA_SIZE 2 |
| |
| #define DEFAULT_FIFO_NAME "xxbadFiFo" |
| #define MAX_NAMELEN 50 |
| |
| struct perf_evlist *evsel_list; |
| |
| /* |
| * command line variables and settings |
| * Default to current process, no_inherit, process |
| */ |
| static pid_t target_pid = -1; /* all */ |
| static bool system_wide; |
| static int cpumask = -1; /* all */ |
| static int ncounts; |
| static int ms_sleep = 1000; /* 1 second */ |
| static char const *operations = "nnnnnnnnnnnnnnnn"; /* nop */ |
| static bool math_enabled; |
| static bool calc_delta; |
| static double old_accum, accum; |
| static int math_op_index; |
| static char const *wfifo_name = DEFAULT_FIFO_NAME; |
| static char const *rfifo_name = DEFAULT_FIFO_NAME; |
| static bool use_fifo; |
| static bool is_ratio; |
| static FILE *fd_in, *fd_out; |
| |
| static FILE *tReadFifo, *tWriteFifo; |
| |
| /* |
| * Raw results from perf, we track the current value and |
| * the old value. |
| */ |
| struct perf_raw_results_s { |
| u64 values; |
| u64 old_value; |
| }; |
| |
| /* |
| * Everything we need to support a perf counter across multiple |
| * CPUs. We need to support multiple file descriptors (perf_fd) |
| * because perf requires a fd per counter, so 1 per core enabled. |
| * |
| * Raw results values are calculated across all the cores as they |
| * are read. |
| */ |
| struct perf_setup_s { |
| int event_index; |
| struct perf_event_attr *attr; |
| int perf_fd[MAX_NR_CPUS]; |
| pid_t pid; |
| int cpu; |
| int flags; |
| int group; |
| struct perf_raw_results_s data; |
| struct perf_raw_results_s totals; |
| struct perf_raw_results_s output; |
| }; |
| |
| static void do_cleanup(void) |
| { |
| if (fd_in) { |
| if (0 != fclose(fd_in)) |
| error("Error closing fd_in\n"); |
| } |
| if (fd_out) { |
| if (0 != fclose(fd_out)) |
| error("Error closing fd_out\n"); |
| } |
| if (use_fifo) { |
| if (0 != unlink(rfifo_name)) |
| error("Error unlinking rfifo\n"); |
| if (0 != unlink(wfifo_name)) |
| error("Error unlinking wfifo\n"); |
| } |
| } |
| |
| /* |
| * Unexpected signal for error indication, cleanup |
| */ |
| static int sig_dummy; |
| static void sig_do_cleanup(int sig) |
| { |
| sig_dummy = sig; |
| do_cleanup(); |
| exit(0); |
| } |
| |
| #define PERIODIC_MAX_STRLEN 100 |
| /* |
| * Delay for either a timed period or the wait on the read_fifo |
| */ |
| static void delay(unsigned long milli) |
| { |
| char tmp_stg[PERIODIC_MAX_STRLEN]; |
| int done; |
| int ret; |
| |
| if (use_fifo) { |
| do { |
| done = true; |
| ret = fscanf(tReadFifo, "%s", tmp_stg); |
| if (ret == 0) |
| return; |
| /* |
| * Look for a command request, and if we get a command |
| * Need to process and then wait again w/o sending data. |
| */ |
| if (strncmp(tmp_stg, "PID", strnlen(tmp_stg, |
| PERIODIC_MAX_STRLEN)) == 0) { |
| fprintf(fd_out, " %u\n", getpid()); |
| fflush(fd_out); |
| done = false; |
| } else if (strncmp(tmp_stg, "EXIT", |
| strnlen(tmp_stg, PERIODIC_MAX_STRLEN)) |
| == 0) { |
| do_cleanup(); |
| exit(0); |
| } |
| |
| } while (done != true); |
| } else |
| usleep(milli*1000); |
| } |
| |
| /* |
| * Create a perf counter event. |
| * Some interesting behaviour that is not documented anywhere else: |
| * the CPU will not work if out of range. |
| * The CPU will only work for a single CPU, so to collect the counts |
| * on the system in SMP based systems a counter needs to be created |
| * for each CPU. |
| */ |
| static int create_perf_counter(struct perf_setup_s *p) |
| { |
| struct cpu_map *cpus; |
| int cpu; |
| |
| cpus = cpu_map__new(NULL); |
| if (p == NULL) |
| return PERF_PERIODIC_ERROR; |
| for (cpu = 0; cpu < cpus->nr; cpu++) { |
| if (((1 << cpu) & cpumask) == 0) |
| continue; |
| p->perf_fd[cpu] = sys_perf_event_open(p->attr, target_pid, cpu, |
| -1, 0); |
| if (p->perf_fd[cpu] < 0) |
| return PERF_PERIODIC_ERROR; |
| } |
| return 0; |
| } |
| |
| /* |
| * Perf init setup |
| */ |
| static int perf_setup_init(struct perf_setup_s *p) |
| { |
| if (p == NULL) |
| return PERF_PERIODIC_ERROR; |
| |
| bzero(p, sizeof(struct perf_setup_s)); |
| p->group = -1; |
| p->flags = 0; |
| |
| p->output.values = 0; |
| p->output.old_value = 0; |
| p->data.values = 0; |
| p->data.old_value = 0; |
| p->totals.old_value = 0; |
| p->totals.values = 0; |
| |
| return 0; |
| } |
| |
| /* |
| * Read in ALL the performance counters configured for the CPU, |
| * one performance monitor per core that was configured during |
| * "all" mode |
| */ |
| static int perf_setup_read(struct perf_setup_s *p) |
| { |
| u64 data[DATA_SIZE]; |
| int i, status; |
| |
| p->totals.values = 0; |
| p->data.values = 0; |
| for (i = 0; i < MAX_NR_CPUS; i++) { |
| if (p->perf_fd[i] == 0) |
| continue; |
| status = read(p->perf_fd[i], &data, sizeof(data)); |
| p->data.values += data[0]; |
| p->totals.values += data[0]; |
| } |
| |
| /* |
| * Normally we show totals, we want to support |
| * showing deltas from the previous value so external apps do not have |
| * to do this... |
| */ |
| if (calc_delta) { |
| p->output.values = p->data.values - p->data.old_value; |
| p->data.old_value = p->data.values; |
| } else |
| p->output.values = p->totals.values; |
| return 0; |
| } |
| |
| static int perf_setup_show(struct perf_setup_s *p) |
| { |
| if (p == NULL) |
| return PERF_PERIODIC_ERROR; |
| fprintf(fd_out, " %llu", p->output.values); |
| return 0; |
| } |
| |
| |
| static const char * const periodic_usage[] = { |
| "perf periodic [<options>]", |
| NULL |
| }; |
| |
| static const struct option options[] = { |
| OPT_CALLBACK('e', "event", &evsel_list, "event", |
| "event selector. use 'perf list' to list available events", |
| parse_events_option), |
| OPT_STRING('m', "math-operations", &operations, "nnnnnn", |
| "math operation to perform on values collected asmd in order"), |
| OPT_STRING('r', "readpipe", &rfifo_name, "xxbadFiFo", |
| "wait for a user input fifo - will be created"), |
| OPT_STRING('w', "writepipe", &wfifo_name, "xxbadFifo", |
| "write data out on this pipe - pipe is created"), |
| OPT_INTEGER('i', "increment", &ncounts, |
| "number of times periods to count/iterate (default 0-forever)"), |
| OPT_INTEGER('p', "pid", &target_pid, |
| "stat events on existing process id"), |
| OPT_INTEGER('c', "cpumask", &cpumask, |
| "cpumask to enable counters, default all (-1)"), |
| OPT_INTEGER('s', "sleep", &ms_sleep, |
| "how long to sleep in ms between each sample (default 1000)"), |
| OPT_BOOLEAN('a', "all-cpus", &system_wide, |
| "system-wide collection from all CPUs overrides cpumask"), |
| OPT_BOOLEAN('d', "delta", &calc_delta, |
| "calculate and display the delta values math funcs will use delta"), |
| OPT_INCR('v', "verbose", &verbose, |
| "be more verbose (show counter open errors, etc)"), |
| OPT_END() |
| }; |
| |
| /* |
| * After every period we reset any math that was performed. |
| */ |
| static void reset_math(void) |
| { |
| math_op_index = 0; |
| old_accum = accum; |
| accum = 0; |
| } |
| |
| static void do_math_op(struct perf_setup_s *p) |
| { |
| if (!math_enabled) |
| return; |
| switch (operations[math_op_index++]) { |
| case 'm': |
| accum *= (double)p->output.values; break; |
| case 'a': |
| accum += (double)p->output.values; break; |
| case 's': |
| accum -= (double)p->output.values; break; |
| case 'd': |
| accum /= (double)p->output.values; break; |
| case 'z': |
| accum = 0; break; |
| case 't': |
| accum = (double)p->output.values; break; /*transfer*/ |
| case 'T': |
| accum += old_accum; break; /*total*/ |
| case 'i': /* ignore */ |
| default: |
| break; |
| } |
| } |
| |
| int cmd_periodic(int argc, const char **argv, const char *prefix __maybe_unused) |
| { |
| int status = 0; |
| int c, i; |
| struct perf_setup_s *p[MAX_COUNTERS]; |
| struct perf_evsel *counter; |
| FILE *fp; |
| int nr_counters = 0; |
| |
| evsel_list = perf_evlist__new(); |
| if (evsel_list == NULL) |
| return -ENOMEM; |
| |
| argc = parse_options(argc, argv, options, periodic_usage, |
| PARSE_OPT_STOP_AT_NON_OPTION); |
| |
| if (system_wide) |
| cpumask = -1; |
| |
| /* |
| * The r & w option redirects stdout to a newly created pipe and |
| * waits for input on the read pipe before continuing |
| */ |
| fd_in = stdin; |
| fd_out = stdout; |
| if (strncmp(rfifo_name, DEFAULT_FIFO_NAME, |
| strnlen(rfifo_name, MAX_NAMELEN))) { |
| fp = fopen(rfifo_name, "r"); |
| if (fp != NULL) { |
| fclose(fp); |
| remove(rfifo_name); |
| } |
| if (mkfifo(rfifo_name, 0777) == -1) { |
| error("Could not open read fifo\n"); |
| do_cleanup(); |
| return PERF_PERIODIC_ERROR; |
| } |
| tReadFifo = fopen(rfifo_name, "r+"); |
| if (tReadFifo == 0) { |
| do_cleanup(); |
| error("Could not open read fifo file\n"); |
| return PERF_PERIODIC_ERROR; |
| } |
| use_fifo = true; |
| } |
| if (strncmp(wfifo_name, DEFAULT_FIFO_NAME, |
| strnlen(wfifo_name, MAX_NAMELEN))) { |
| fp = fopen(wfifo_name, "r"); |
| if (fp != NULL) { |
| fclose(fp); |
| remove(wfifo_name); |
| } |
| if (mkfifo(wfifo_name, 0777) == -1) { |
| do_cleanup(); |
| error("Could not open write fifo\n"); |
| return PERF_PERIODIC_ERROR; |
| } |
| fd_out = fopen(wfifo_name, "w+"); |
| if (fd_out == 0) { |
| do_cleanup(); |
| error("Could not open write fifo file\n"); |
| return PERF_PERIODIC_ERROR; |
| } |
| tWriteFifo = fd_out; |
| } |
| |
| math_enabled = (operations[0] != 'n'); |
| |
| /* |
| * If we don't ignore SIG_PIPE then when the other side |
| * of a pipe closes we shutdown too... |
| */ |
| signal(SIGPIPE, SIG_IGN); |
| signal(SIGINT, sig_do_cleanup); |
| signal(SIGQUIT, sig_do_cleanup); |
| signal(SIGKILL, sig_do_cleanup); |
| signal(SIGTERM, sig_do_cleanup); |
| |
| i = 0; |
| list_for_each_entry(counter, &evsel_list->entries, node) { |
| p[i] = malloc(sizeof(struct perf_setup_s)); |
| if (p[i] == NULL) { |
| error("Error allocating perf_setup_s\n"); |
| do_cleanup(); |
| return PERF_PERIODIC_ERROR; |
| } |
| bzero(p[i], sizeof(struct perf_setup_s)); |
| perf_setup_init(p[i]); |
| p[i]->attr = &(counter->attr); |
| p[i]->event_index = counter->idx; |
| if (create_perf_counter(p[i]) < 0) { |
| do_cleanup(); |
| die("Not all events could be opened.\n"); |
| return PERF_PERIODIC_ERROR; |
| } |
| i++; |
| nr_counters++; |
| } |
| i = 0; |
| while (1) { |
| |
| /* |
| * Wait first otherwise single sample will print w/o signal |
| * when using the -u (user signal) flag |
| */ |
| delay(ms_sleep); |
| |
| /* |
| * Do the collection, read and then perform any math operations |
| */ |
| for (c = 0; c < nr_counters; c++) { |
| status = perf_setup_read(p[c]); |
| do_math_op(p[c]); |
| } |
| |
| /* |
| * After all collection and math, we perform one last math |
| * to allow totaling, if enabled etc, then either printout |
| * a single float value when the math is enabled or ... |
| */ |
| if (math_enabled) { |
| do_math_op(p[c]); |
| if (is_ratio) |
| fprintf(fd_out, "%#f\n", accum*100); |
| else |
| fprintf(fd_out, "%#f\n", accum); |
| } else { |
| /* |
| * ... print out one integer value for each counter |
| */ |
| for (c = 0; c < nr_counters; c++) |
| status = perf_setup_show(p[c]); |
| fprintf(fd_out, "\n"); |
| } |
| |
| /* |
| * Did the user give us an iteration count? |
| */ |
| if ((ncounts != 0) && (++i >= ncounts)) |
| break; |
| reset_math(); |
| fflush(fd_out); /* make sure data is flushed out the pipe*/ |
| } |
| |
| do_cleanup(); |
| |
| return status; |
| } |