Merge tag 'perf-core-for-mingo-4.12-20170324' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

User visible changes:

 - Allow suppressing 'uncore_' when specifying PMU events (Andi Kleen)

 - Collapse identically named PMU events in 'perf stat', allow
   not merging it via --no-merge (Andi Kleen)

Fixes:

 - Use more precise 'grep -v' to suppress unwanted 'objdump -dS'
   disassembly output to not ditch line:number lines needed by
   'perf annotate --print-lines' logic (Taeung Song)

Infrastructure changes:

 - SDT (Statically Defined Tracing)/uprobes_events arguments improvements
   (Alexis Berlemont, Ravi Bangoria)

 - Improvements for the handling of JSON described vendor events,
   including having an expression parser to calculate metrics
   from multiple vendor events (Andi Kleen)

 - Update Intel JSON vendor event files (Andi Kleen)

 - Restore error reporting in 'perf probe -d' when none of the events
   requested to be deleted exist. (Kefeng Wang)

 - Bump MAX_CMDLEN in 'perf probe' to match what the kernel accepts
   (Ravi Bangoria)

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

1 files changed, 123 insertions, 23 deletions

diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index f53f449d864d..01b589e3c3a6 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -140,6 +140,7 @@ static unsigned int		unit_width			= 4; /* strlen("unit") */
 static bool                     forever                         = false;
 static bool                     metric_only                     = false;
 static bool                     force_metric_only               = false;
+static bool                     no_merge                        = false;
 static struct timespec          ref_time;
 static struct cpu_map           *aggr_map;
 static aggr_get_id_t            aggr_get_id;
@@ -1144,6 +1145,7 @@ static void printout(int id, int nr, struct perf_evsel *counter, double uval,
         out.print_metric = pm;
         out.new_line = nl;
         out.ctx = &os;
+        out.force_header = false;
 
         if (csv_output && !metric_only) {
                 print_noise(counter, noise);
@@ -1182,11 +1184,81 @@ static void aggr_update_shadow(void)
         }
 }
 
+static void collect_all_aliases(struct perf_evsel *counter,
+                            void (*cb)(struct perf_evsel *counter, void *data,
+                                       bool first),
+                            void *data)
+{
+        struct perf_evsel *alias;
+
+        alias = list_prepare_entry(counter, &(evsel_list->entries), node);
+        list_for_each_entry_continue (alias, &evsel_list->entries, node) {
+                if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) ||
+                    alias->scale != counter->scale ||
+                    alias->cgrp != counter->cgrp ||
+                    strcmp(alias->unit, counter->unit) ||
+                    nsec_counter(alias) != nsec_counter(counter))
+                        break;
+                alias->merged_stat = true;
+                cb(alias, data, false);
+        }
+}
+
+static bool collect_data(struct perf_evsel *counter,
+                            void (*cb)(struct perf_evsel *counter, void *data,
+                                       bool first),
+                            void *data)
+{
+        if (counter->merged_stat)
+                return false;
+        cb(counter, data, true);
+        if (!no_merge)
+                collect_all_aliases(counter, cb, data);
+        return true;
+}
+
+struct aggr_data {
+        u64 ena, run, val;
+        int id;
+        int nr;
+        int cpu;
+};
+
+static void aggr_cb(struct perf_evsel *counter, void *data, bool first)
+{
+        struct aggr_data *ad = data;
+        int cpu, s2;
+
+        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
+                struct perf_counts_values *counts;
+
+                s2 = aggr_get_id(perf_evsel__cpus(counter), cpu);
+                if (s2 != ad->id)
+                        continue;
+                if (first)
+                        ad->nr++;
+                counts = perf_counts(counter->counts, cpu, 0);
+                /*
+                 * When any result is bad, make them all to give
+                 * consistent output in interval mode.
+                 */
+                if (counts->ena == 0 || counts->run == 0 ||
+                    counter->counts->scaled == -1) {
+                        ad->ena = 0;
+                        ad->run = 0;
+                        break;
+                }
+                ad->val += counts->val;
+                ad->ena += counts->ena;
+                ad->run += counts->run;
+        }
+}
+
 static void print_aggr(char *prefix)
 {
         FILE *output = stat_config.output;
         struct perf_evsel *counter;
-        int cpu, s, s2, id, nr;
+        int s, id, nr;
         double uval;
         u64 ena, run, val;
         bool first;
@@ -1201,23 +1273,21 @@ static void print_aggr(char *prefix)
          * Without each counter has its own line.
          */
         for (s = 0; s < aggr_map->nr; s++) {
+                struct aggr_data ad;
                 if (prefix && metric_only)
                         fprintf(output, "%s", prefix);
 
-                id = aggr_map->map[s];
+                ad.id = id = aggr_map->map[s];
                 first = true;
                 evlist__for_each_entry(evsel_list, counter) {
-                        val = ena = run = 0;
-                        nr = 0;
-                        for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                                s2 = aggr_get_id(perf_evsel__cpus(counter), cpu);
-                                if (s2 != id)
-                                        continue;
-                                val += perf_counts(counter->counts, cpu, 0)->val;
-                                ena += perf_counts(counter->counts, cpu, 0)->ena;
-                                run += perf_counts(counter->counts, cpu, 0)->run;
-                                nr++;
-                        }
+                        ad.val = ad.ena = ad.run = 0;
+                        ad.nr = 0;
+                        if (!collect_data(counter, aggr_cb, &ad))
+                                continue;
+                        nr = ad.nr;
+                        ena = ad.ena;
+                        run = ad.run;
+                        val = ad.val;
                         if (first && metric_only) {
                                 first = false;
                                 aggr_printout(counter, id, nr);
@@ -1261,6 +1331,21 @@ static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
         }
 }
 
+struct caggr_data {
+        double avg, avg_enabled, avg_running;
+};
+
+static void counter_aggr_cb(struct perf_evsel *counter, void *data,
+                            bool first __maybe_unused)
+{
+        struct caggr_data *cd = data;
+        struct perf_stat_evsel *ps = counter->priv;
+
+        cd->avg += avg_stats(&ps->res_stats[0]);
+        cd->avg_enabled += avg_stats(&ps->res_stats[1]);
+        cd->avg_running += avg_stats(&ps->res_stats[2]);
+}
+
 /*
  * Print out the results of a single counter:
  * aggregated counts in system-wide mode
@@ -1268,23 +1353,31 @@ static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
 static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
 {
         FILE *output = stat_config.output;
-        struct perf_stat_evsel *ps = counter->priv;
-        double avg = avg_stats(&ps->res_stats[0]);
         double uval;
-        double avg_enabled, avg_running;
+        struct caggr_data cd = { .avg = 0.0 };
 
-        avg_enabled = avg_stats(&ps->res_stats[1]);
-        avg_running = avg_stats(&ps->res_stats[2]);
+        if (!collect_data(counter, counter_aggr_cb, &cd))
+                return;
 
         if (prefix && !metric_only)
                 fprintf(output, "%s", prefix);
 
-        uval = avg * counter->scale;
-        printout(-1, 0, counter, uval, prefix, avg_running, avg_enabled, avg);
+        uval = cd.avg * counter->scale;
+        printout(-1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled, cd.avg);
         if (!metric_only)
                 fprintf(output, "\n");
 }
 
+static void counter_cb(struct perf_evsel *counter, void *data,
+                       bool first __maybe_unused)
+{
+        struct aggr_data *ad = data;
+
+        ad->val += perf_counts(counter->counts, ad->cpu, 0)->val;
+        ad->ena += perf_counts(counter->counts, ad->cpu, 0)->ena;
+        ad->run += perf_counts(counter->counts, ad->cpu, 0)->run;
+}
+
 /*
  * Print out the results of a single counter:
  * does not use aggregated count in system-wide
@@ -1297,9 +1390,13 @@ static void print_counter(struct perf_evsel *counter, char *prefix)
         int cpu;
 
         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
-                val = perf_counts(counter->counts, cpu, 0)->val;
-                ena = perf_counts(counter->counts, cpu, 0)->ena;
-                run = perf_counts(counter->counts, cpu, 0)->run;
+                struct aggr_data ad = { .cpu = cpu };
+
+                if (!collect_data(counter, counter_cb, &ad))
+                        return;
+                val = ad.val;
+                ena = ad.ena;
+                run = ad.run;
 
                 if (prefix)
                         fprintf(output, "%s", prefix);
@@ -1384,6 +1481,7 @@ static void print_metric_headers(const char *prefix, bool no_indent)
                 out.ctx = &os;
                 out.print_metric = print_metric_header;
                 out.new_line = new_line_metric;
+                out.force_header = true;
                 os.evsel = counter;
                 perf_stat__print_shadow_stats(counter, 0,
                                               0,
@@ -1644,6 +1742,7 @@ static const struct option stat_options[] = {
                     "list of cpus to monitor in system-wide"),
         OPT_SET_UINT('A', "no-aggr", &stat_config.aggr_mode,
                     "disable CPU count aggregation", AGGR_NONE),
+        OPT_BOOLEAN(0, "no-merge", &no_merge, "Do not merge identical named events"),
         OPT_STRING('x', "field-separator", &csv_sep, "separator",
                    "print counts with custom separator"),
         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
@@ -2401,6 +2500,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
         argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands,
                                         (const char **) stat_usage,
                                         PARSE_OPT_STOP_AT_NON_OPTION);
+        perf_stat__collect_metric_expr(evsel_list);
         perf_stat__init_shadow_stats();
 
         if (csv_sep) {