Re: [PATCH 5/7] perf metricgroup: Remove duped metric group events

On Wed, May 20, 2020 at 6:49 AM Jiri Olsa [off-list ref] wrote:

On Wed, May 20, 2020 at 12:28:12AM -0700, Ian Rogers wrote:

SNIP

quoted

@@ -157,7 +183,7 @@ static int metricgroup__setup_events(struct list_head *groups,
      int i = 0;
      int ret = 0;
      struct egroup *eg;
-     struct evsel *evsel;
+     struct evsel *evsel, *tmp;
      unsigned long *evlist_used;

      evlist_used = bitmap_alloc(perf_evlist->core.nr_entries);

@@ -173,7 +199,8 @@ static int metricgroup__setup_events(struct list_head *groups,
                      ret = -ENOMEM;
                      break;
              }
-             evsel = find_evsel_group(perf_evlist, &eg->pctx, metric_events,
+             evsel = find_evsel_group(perf_evlist, &eg->pctx,
+                                     eg->has_constraint, metric_events,
                                      evlist_used);
              if (!evsel) {
                      pr_debug("Cannot resolve %s: %s\n",

@@ -200,6 +227,12 @@ static int metricgroup__setup_events(struct list_head *groups,
              list_add(&expr->nd, &me->head);
      }

+     evlist__for_each_entry_safe(perf_evlist, tmp, evsel) {
+             if (!test_bit(evsel->idx, evlist_used)) {
+                     evlist__remove(perf_evlist, evsel);
+                     evsel__delete(evsel);
+             }

is the groupping still enabled when we merge groups? could part
of the metric (events) be now computed in different groups?

By default the change will take two metrics and allow the shorter
metric (in terms of number of events) to share the events of the
longer metric. If the events for the shorter metric aren't in the
longer metric then the shorter metric must use its own group of
events. If sharing has occurred then the bitmap is used to work out
which events and groups are no longer in use.

With --metric-no-group then any event can be used for a metric as
there is no grouping. This is why more events can be eliminated.

With --metric-no-merge then the logic to share events between
different metrics is disabled and every metric is in a group. This
allows the current behavior to be had.

There are some corner cases, such as metrics with constraints (that
don't group) and duration_time that is never placed into a group.

Partial sharing, with one event in 1 weak event group and 1 in another
is never performed. Using --metric-no-group allows something similar.
Given multiplexing, I'd be concerned about accuracy problems if events
between groups were shared - say for IPC, were you measuring
instructions and cycles at the same moment?

I was wondering if we could merge all the hasmaps into single
one before the parse the evlist.. this way we won't need removing
later.. but I did not thought this through completely, so it
might not work at some point

This could be done in the --metric-no-group case reasonably easily
like the current hashmap. For groups you'd want something like a set
of sets of events, but then you'd only be able to share events if the
sets were the same. A directed acyclic graph could capture the events
and the sharing relationships, it may be possible to optimize cases
like {A,B,C}, {A,B,D}, {A,B} so that the small group on the end shares
events with both the {A,B,C} and {A,B,D} group. This may be good
follow up work. We could also solve this in the json, for example
create a "phony" group of {A,B,C,D} that all three metrics share from.
You could also use --metric-no-group to achieve that sharing now.

Thanks,
Ian

jirka