perf script: Change metric format to use json metrics

The metric format option isn't properly supported. This change
improves that by making the sample events update the counts of an
evsel, where the shadow metric code expects to read the values.  To
support printing metrics, metrics need to be found. This is done on
the first attempt to print a metric. Every metric is parsed and then
the evsels in the metric's evlist compared to those in perf script
using the perf_event_attr type and config. If the metric matches then
it is added for printing. As an event in the perf script's evlist may
have >1 metric id, or different leader for aggregation, the first
metric matched will be displayed in those cases.

An example use is:
```
$ perf record -a -e '{instructions,cpu-cycles}:S' -a -- sleep 1
$ perf script -F period,metric
...
     867817
         metric:    0.30  insn per cycle
     125394
         metric:    0.04  insn per cycle
     313516
         metric:    0.11  insn per cycle
         metric:    1.00  insn per cycle
```

Signed-off-by: Ian Rogers <irogers@google.com>
Signed-off-by: Namhyung Kim <namhyung@kernel.org>

diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index d813adbf9889545ca3014fae9923ec69235b376f..8bab5b264f6136bba77e7b13b21fbb9e1536b478 100644 (file)
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -33,6 +33,7 @@
 #include "util/path.h"
 #include "util/event.h"
 #include "util/mem-info.h"
+#include "util/metricgroup.h"
 #include "ui/ui.h"
 #include "print_binary.h"
 #include "print_insn.h"
@@ -341,9 +342,6 @@ struct evsel_script {
        char *filename;
        FILE *fp;
        u64  samples;
-       /* For metric output */
-       u64  val;
-       int  gnum;
 };
 
 static inline struct evsel_script *evsel_script(struct evsel *evsel)
@@ -2132,13 +2130,161 @@ static void script_new_line(struct perf_stat_config *config __maybe_unused,
        fputs("\tmetric: ", mctx->fp);
 }
 
-static void perf_sample__fprint_metric(struct perf_script *script,
-                                      struct thread *thread,
+struct script_find_metrics_args {
+       struct evlist *evlist;
+       bool system_wide;
+};
+
+static struct evsel *map_metric_evsel_to_script_evsel(struct evlist *script_evlist,
+                                                     struct evsel *metric_evsel)
+{
+       struct evsel *script_evsel;
+
+       evlist__for_each_entry(script_evlist, script_evsel) {
+               /* Skip if perf_event_attr differ. */
+               if (metric_evsel->core.attr.type != script_evsel->core.attr.type)
+                       continue;
+               if (metric_evsel->core.attr.config != script_evsel->core.attr.config)
+                       continue;
+               /* Skip if the script event has a metric_id that doesn't match. */
+               if (script_evsel->metric_id &&
+                   strcmp(evsel__metric_id(metric_evsel), evsel__metric_id(script_evsel))) {
+                       pr_debug("Skipping matching evsel due to differing metric ids '%s' vs '%s'\n",
+                                evsel__metric_id(metric_evsel), evsel__metric_id(script_evsel));
+                       continue;
+               }
+               return script_evsel;
+       }
+       return NULL;
+}
+
+static int script_find_metrics(const struct pmu_metric *pm,
+                              const struct pmu_metrics_table *table __maybe_unused,
+                              void *data)
+{
+       struct script_find_metrics_args *args = data;
+       struct evlist *script_evlist = args->evlist;
+       struct evlist *metric_evlist = evlist__new();
+       struct evsel *metric_evsel;
+       int ret = metricgroup__parse_groups(metric_evlist,
+                                       /*pmu=*/"all",
+                                       pm->metric_name,
+                                       /*metric_no_group=*/false,
+                                       /*metric_no_merge=*/false,
+                                       /*metric_no_threshold=*/true,
+                                       /*user_requested_cpu_list=*/NULL,
+                                       args->system_wide,
+                                       /*hardware_aware_grouping=*/false);
+
+       if (ret) {
+               /* Metric parsing failed but continue the search. */
+               goto out;
+       }
+
+       /*
+        * Check the script_evlist has an entry for each metric_evlist entry. If
+        * the script evsel was already set up avoid changing data that may
+        * break it.
+        */
+       evlist__for_each_entry(metric_evlist, metric_evsel) {
+               struct evsel *script_evsel =
+                       map_metric_evsel_to_script_evsel(script_evlist, metric_evsel);
+               struct evsel *new_metric_leader;
+
+               if (!script_evsel) {
+                       pr_debug("Skipping metric '%s' as evsel '%s' / '%s' is missing\n",
+                               pm->metric_name, evsel__name(metric_evsel),
+                               evsel__metric_id(metric_evsel));
+                       goto out;
+               }
+
+               if (script_evsel->metric_leader == NULL)
+                       continue;
+
+               if (metric_evsel->metric_leader == metric_evsel) {
+                       new_metric_leader = script_evsel;
+               } else {
+                       new_metric_leader =
+                               map_metric_evsel_to_script_evsel(script_evlist,
+                                                                metric_evsel->metric_leader);
+               }
+               /* Mismatching evsel leaders. */
+               if (script_evsel->metric_leader != new_metric_leader) {
+                       pr_debug("Skipping metric '%s' due to mismatching evsel metric leaders '%s' vs '%s'\n",
+                               pm->metric_name, evsel__metric_id(metric_evsel),
+                               evsel__metric_id(script_evsel));
+                       goto out;
+               }
+       }
+       /*
+        * Metric events match those in the script evlist, copy metric evsel
+        * data into the script evlist.
+        */
+       evlist__for_each_entry(metric_evlist, metric_evsel) {
+               struct evsel *script_evsel =
+                       map_metric_evsel_to_script_evsel(script_evlist, metric_evsel);
+               struct metric_event *metric_me = metricgroup__lookup(&metric_evlist->metric_events,
+                                                                    metric_evsel,
+                                                                    /*create=*/false);
+
+               if (script_evsel->metric_id == NULL) {
+                       script_evsel->metric_id = metric_evsel->metric_id;
+                       metric_evsel->metric_id = NULL;
+               }
+
+               if (script_evsel->metric_leader == NULL) {
+                       if (metric_evsel->metric_leader == metric_evsel) {
+                               script_evsel->metric_leader = script_evsel;
+                       } else {
+                               script_evsel->metric_leader =
+                                       map_metric_evsel_to_script_evsel(script_evlist,
+                                                                      metric_evsel->metric_leader);
+                       }
+               }
+
+               if (metric_me) {
+                       struct metric_expr *expr;
+                       struct metric_event *script_me =
+                               metricgroup__lookup(&script_evlist->metric_events,
+                                                   script_evsel,
+                                                   /*create=*/true);
+
+                       if (!script_me) {
+                               /*
+                                * As the metric_expr is created, the only
+                                * failure is a lack of memory.
+                                */
+                               goto out;
+                       }
+                       list_splice_init(&metric_me->head, &script_me->head);
+                       list_for_each_entry(expr, &script_me->head, nd) {
+                               for (int i = 0; expr->metric_events[i]; i++) {
+                                       expr->metric_events[i] =
+                                               map_metric_evsel_to_script_evsel(script_evlist,
+                                                                       expr->metric_events[i]);
+                               }
+                       }
+               }
+       }
+       pr_debug("Found metric '%s' whose evsels match those of in the perf data\n",
+                pm->metric_name);
+       evlist__delete(metric_evlist);
+out:
+       return 0;
+}
+
+static struct aggr_cpu_id script_aggr_cpu_id_get(struct perf_stat_config *config __maybe_unused,
+                                                   struct perf_cpu cpu)
+{
+       return aggr_cpu_id__global(cpu, /*data=*/NULL);
+}
+
+static void perf_sample__fprint_metric(struct thread *thread,
                                       struct evsel *evsel,
                                       struct perf_sample *sample,
                                       FILE *fp)
 {
-       struct evsel *leader = evsel__leader(evsel);
+       static bool init_metrics;
        struct perf_stat_output_ctx ctx = {
                .print_metric = script_print_metric,
                .new_line = script_new_line,
@@ -2150,23 +2296,85 @@ static void perf_sample__fprint_metric(struct perf_script *script,
                         },
                .force_header = false,
        };
-       struct evsel *ev2;
-       u64 val;
+       struct perf_counts_values *count, *old_count;
+       int cpu_map_idx, thread_map_idx, aggr_idx;
+       struct evsel *pos;
+
+       if (!init_metrics) {
+               /* One time initialization of stat_config and metric data. */
+               struct script_find_metrics_args args = {
+                       .evlist = evsel->evlist,
+                       .system_wide = perf_thread_map__pid(evsel->core.threads, /*idx=*/0) == -1,
+
+               };
+               if (!stat_config.output)
+                       stat_config.output = stdout;
+
+               if (!stat_config.aggr_map) {
+                       /* TODO: currently only global aggregation is supported. */
+                       assert(stat_config.aggr_mode == AGGR_GLOBAL);
+                       stat_config.aggr_get_id = script_aggr_cpu_id_get;
+                       stat_config.aggr_map =
+                               cpu_aggr_map__new(evsel->evlist->core.user_requested_cpus,
+                                                 aggr_cpu_id__global, /*data=*/NULL,
+                                                 /*needs_sort=*/false);
+               }
+
+               metricgroup__for_each_metric(pmu_metrics_table__find(), script_find_metrics, &args);
+               init_metrics = true;
+       }
+
+       if (!evsel->stats) {
+               if (evlist__alloc_stats(&stat_config, evsel->evlist, /*alloc_raw=*/true) < 0)
+                       return;
+       }
+       if (!evsel->stats->aggr) {
+               if (evlist__alloc_aggr_stats(evsel->evlist, stat_config.aggr_map->nr) < 0)
+                       return;
+       }
 
-       if (!evsel->stats)
-               evlist__alloc_stats(&stat_config, script->session->evlist, /*alloc_raw=*/false);
-       if (evsel_script(leader)->gnum++ == 0)
-               perf_stat__reset_shadow_stats();
-       val = sample->period * evsel->scale;
-       evsel_script(evsel)->val = val;
-       if (evsel_script(leader)->gnum == leader->core.nr_members) {
-               for_each_group_member (ev2, leader) {
-                       perf_stat__print_shadow_stats(&stat_config, ev2,
-                                                     evsel_script(ev2)->val,
-                                                     sample->cpu,
-                                                     &ctx);
+       /* Update the evsel's count using the sample's data. */
+       cpu_map_idx = perf_cpu_map__idx(evsel->core.cpus, (struct perf_cpu){sample->cpu});
+       if (cpu_map_idx < 0) {
+               /* Missing CPU, check for any CPU. */
+               if (perf_cpu_map__cpu(evsel->core.cpus, /*idx=*/0).cpu == -1 ||
+                   sample->cpu == (u32)-1) {
+                       /* Place the counts in the which ever CPU is first in the map. */
+                       cpu_map_idx = 0;
+               } else {
+                       pr_info("Missing CPU map entry for CPU %d\n", sample->cpu);
+                       return;
+               }
+       }
+       thread_map_idx = perf_thread_map__idx(evsel->core.threads, sample->tid);
+       if (thread_map_idx < 0) {
+               /* Missing thread, check for any thread. */
+               if (perf_thread_map__pid(evsel->core.threads, /*idx=*/0) == -1 ||
+                   sample->tid == (u32)-1) {
+                       /* Place the counts in the which ever thread is first in the map. */
+                       thread_map_idx = 0;
+               } else {
+                       pr_info("Missing thread map entry for thread %d\n", sample->tid);
+                       return;
+               }
+       }
+       count = perf_counts(evsel->counts, cpu_map_idx, thread_map_idx);
+       old_count = perf_counts(evsel->prev_raw_counts, cpu_map_idx, thread_map_idx);
+       count->val = old_count->val + sample->period;
+       count->run = old_count->run + 1;
+       count->ena = old_count->ena + 1;
+
+       /* Update the aggregated stats. */
+       perf_stat_process_counter(&stat_config, evsel);
+
+       /* Display all metrics. */
+       evlist__for_each_entry(evsel->evlist, pos) {
+               cpu_aggr_map__for_each_idx(aggr_idx, stat_config.aggr_map) {
+                       perf_stat__print_shadow_stats(&stat_config, pos,
+                                               count->val,
+                                               aggr_idx,
+                                               &ctx);
                }
-               evsel_script(leader)->gnum = 0;
        }
 }
 
@@ -2348,7 +2556,7 @@ static void process_event(struct perf_script *script,
        }
 
        if (PRINT_FIELD(METRIC))
-               perf_sample__fprint_metric(script, thread, evsel, sample, fp);
+               perf_sample__fprint_metric(thread, evsel, sample, fp);
 
        if (verbose > 0)
                fflush(fp);