Fixes for Intel TMA, particularly for hybrid
Ian Rogers
reviewerv3 cover Fixes for Intel TMA, particularly for hybrid
On hybrid systems some PMUs apply to all core types, particularly for metrics the msr PMU and the tsc event. The metrics often only want the values of the counter for their specific core type. These patches allow the cpu term in an event to give a PMU name to take the cpumask from. For example:
$ perf stat -e msr/tsc,cpu=cpu_atom/ ...
will aggregate the msr/tsc/ value but only for atom cores. In doing this problems were identified in how cpumasks are handled by parsing and event setup when cpumasks are specified along with a task to profile. The event parsing, cpumask evlist propagation code and perf stat code are updated accordingly.
The final result of the patch series is to be able to run:
```
$ perf stat --no-scale -e 'msr/tsc/,msr/tsc,cpu=cpu_core/,msr/tsc,cpu=cpu_atom/' perf test -F 10
10.1: Basic parsing test : Ok
10.2: Parsing without PMU name : Ok
10.3: Parsing with PMU name : Ok
Performance counter stats for 'perf test -F 10':
63,704,975 msr/tsc/
47,060,704 msr/tsc,cpu=cpu_core/ (4.62%)
16,640,591 msr/tsc,cpu=cpu_atom/ (2.18%)
```This has (further) identified a kernel bug for task events around the enabled time being too large leading to invalid scaling (hence the
--no-scale in the command line above).
Additionally the series corrects topdown event processing and starts injecting slots events as preparation for TMA 5.1 whose updates will be sent as a follow-up patch series.
v3: Fix CPU map computation for uncore/requires_cpu, don't simplify
for the "any"(-1) CPU case. Combine with topdown slots/fix and injection previously:
https://lore.kernel.org/lkml/[email protected]/
This has a grouping fix added for the injected slots event. Add new no grouping constraint for threshold + NMI for issue with alderlake metrics failing to schedule when thresholds are enabled along with the NMI watchdog.
v2: Add additional documentation of the cpu term to perf list
(Namhyung), extend the term to also allow CPU ranges. Add Thomas Falcon's reviewed-by. Still open for discussion whether the term cpu should have >1 variant for PMUs, etc. or whether the single term is okay. We could refactor later and add a term, but that would break existing users, but they are most likely to be metrics so probably not a huge issue.
Ian Rogers (15):
perf parse-events: Warn if a cpu term is unsupported by a CPU perf stat: Avoid buffer overflow to the aggregation map perf stat: Don't size aggregation ids from user_requested_cpus perf parse-events: Allow the cpu term to be a PMU or CPU range perf tool_pmu: Allow num_cpus(_online) to be specific to a cpumask libperf evsel: Rename own_cpus to pmu_cpus
libperf evsel: Factor perf_evsel__exit out of perf_evsel__delete perf evsel: Use libperf perf_evsel__exit
perf pmus: Factor perf_pmus__find_by_attr out of evsel__find_pmu perf parse-events: Minor __add_event refactoring
perf evsel: Add evsel__open_per_cpu_and_thread
perf parse-events: Support user CPUs mixed with threads/processes perf topdown: Use attribute to see an event is a topdown metic or
slots
perf parse-events: Fix missing slots for Intel topdown metric events perf metricgroups: Add NO_THRESHOLD_AND_NMI constraint
tools/lib/perf/evlist.c | 119 +++++++++++++++------- tools/lib/perf/evsel.c | 9 +- tools/lib/perf/include/internal/evsel.h | 3 +- tools/perf/Documentation/perf-list.txt | 25 +++-- tools/perf/arch/x86/include/arch-tests.h | 4 + tools/perf/arch/x86/tests/Build | 1 + tools/perf/arch/x86/tests/arch-tests.c | 1 + tools/perf/arch/x86/tests/topdown.c | 76 ++++++++++++++ tools/perf/arch/x86/util/evlist.c | 24 +++++ tools/perf/arch/x86/util/evsel.c | 46 +++------ tools/perf/arch/x86/util/topdown.c | 59 +++++++---- tools/perf/arch/x86/util/topdown.h | 6 ++ tools/perf/builtin-stat.c | 9 +- tools/perf/pmu-events/jevents.py | 1 + tools/perf/pmu-events/pmu-events.h | 14 ++- tools/perf/tests/event_update.c | 4 +- tools/perf/tests/parse-events.c | 24 ++--- tools/perf/util/evlist.c | 15 +-- tools/perf/util/evlist.h | 1 + tools/perf/util/evsel.c | 55 ++++++++-- tools/perf/util/evsel.h | 5 + tools/perf/util/expr.c | 2 +- tools/perf/util/header.c | 4 +- tools/perf/util/metricgroup.c | 16 ++- tools/perf/util/parse-events.c | 122 ++++++++++++++++++----- tools/perf/util/pmus.c | 29 +++--- tools/perf/util/pmus.h | 2 + tools/perf/util/stat.c | 6 +- tools/perf/util/synthetic-events.c | 4 +- tools/perf/util/tool_pmu.c | 56 +++++++++-- tools/perf/util/tool_pmu.h | 2 +- 31 files changed, 532 insertions(+), 212 deletions(-) create mode 100644 tools/perf/arch/x86/tests/topdown.c
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 1/15 perf parse-events: Warn if a cpu term is unsupported by a CPU
Factor requested CPU warning out of evlist and into evsel. At the end of adding an event, perform the warning check. To avoid repeatedly testing if the cpu_list is empty, add a local variable.
```
$ perf stat -e cpu_atom/cycles,cpu=1/ -a true
WARNING: A requested CPU in '1' is not supported by PMU 'cpu_atom' (CPUs 16-27) for event 'cpu_atom/cycles/'
Performance counter stats for 'system wide':
<not supported> cpu_atom/cycles/
0.000781511 seconds time elapsed
```--- tools/perf/util/evlist.c | 15 +-------------- tools/perf/util/evsel.c | 24 ++++++++++++++++++++++++ tools/perf/util/evsel.h | 2 ++ tools/perf/util/parse-events.c | 12 ++++++++---- 4 files changed, 35 insertions(+), 18 deletions(-)
tools/perf/util/evlist.c +1 -14
@@ -2549,20 +2549,7 @@ void evlist__warn_user_requested_cpus(struct evlist *evlist, const char *cpu_lisreturn ;evlist__for_each_entry (evlist, pos) { -struct perf_cpu_map *intersect, *to_test, *online =cpu_map__online (); -const struct perf_pmu *pmu =evsel__find_pmu (pos); - - to_test = pmu && pmu->is_core ? pmu->cpus : online; - intersect =perf_cpu_map__intersect (to_test, user_requested_cpus); -if (!perf_cpu_map__equal (intersect, user_requested_cpus)) { -char buf[128 ]; - -cpu_map__snprint (to_test, buf,sizeof (buf)); -pr_warning ("WARNING: A requested CPU in '%s' is not supported by PMU '%s' (CPUs %s) for event '%s'\n" , - cpu_list, pmu ? pmu->name :"cpu" , buf,evsel__name (pos)); - } -perf_cpu_map__put (intersect); -perf_cpu_map__put (online); +evsel__warn_user_requested_cpus (pos, user_requested_cpus); }perf_cpu_map__put (user_requested_cpus); }
tools/perf/util/evsel.c +24 -0
@@ -4091,3 +4091,27 @@ void evsel__uniquify_counter(struct evsel *counter) counter->uniquified_name = false; } } + +void evsel__warn_user_requested_cpus (struct evsel *evsel,struct perf_cpu_map *user_requested_cpus) +{ +struct perf_cpu_map *intersect, *online =NULL ; +const struct perf_pmu *pmu =evsel__find_pmu (evsel); + +if (pmu && pmu->is_core) { + intersect =perf_cpu_map__intersect (pmu->cpus, user_requested_cpus); + }else { + online =cpu_map__online (); + intersect =perf_cpu_map__intersect (online, user_requested_cpus); + } +if (!perf_cpu_map__equal (intersect, user_requested_cpus)) { +char buf1[128 ]; +char buf2[128 ]; + +cpu_map__snprint (user_requested_cpus, buf1,sizeof (buf1)); +cpu_map__snprint (online ?: pmu->cpus, buf2,sizeof (buf2)); +pr_warning ("WARNING: A requested CPU in '%s' is not supported by PMU '%s' (CPUs %s) for event '%s'\n" , + buf1, pmu ? pmu->name :"cpu" , buf2,evsel__name (evsel)); + } +perf_cpu_map__put (intersect); +perf_cpu_map__put (online); +}
tools/perf/util/evsel.h +2 -0
@@ -574,4 +574,6 @@ void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel,bool evsel__is_offcpu_event (struct evsel *evsel); +void evsel__warn_user_requested_cpus (struct evsel *evsel,struct perf_cpu_map *user_requested_cpus); +#endif /* __PERF_EVSEL_H */
tools/perf/util/parse-events.c +8 -4
@@ -252,6 +252,7 @@ __add_event(struct list_head *list, int *idx,struct evsel *evsel;bool is_pmu_core;struct perf_cpu_map *cpus; +bool has_cpu_list = !perf_cpu_map__is_empty (cpu_list);/* * Ensure the first_wildcard_match's PMU matches that of the new event
@@ -276,7 +277,7 @@ __add_event(struct list_head *list, int *idx,if (pmu) { is_pmu_core = pmu->is_core; - cpus =perf_cpu_map__get (perf_cpu_map__is_empty (cpu_list) ? pmu->cpus : cpu_list); + cpus =perf_cpu_map__get (has_cpu_list ? cpu_list : pmu->cpus);perf_pmu__warn_invalid_formats (pmu);if (attr->type ==PERF_TYPE_RAW || attr->type >=PERF_TYPE_MAX ) { perf_pmu__warn_invalid_config(pmu, attr->config, name,
@@ -291,10 +292,10 @@ __add_event(struct list_head *list, int *idx, }else { is_pmu_core = (attr->type ==PERF_TYPE_HARDWARE || attr->type ==PERF_TYPE_HW_CACHE ); -if (perf_cpu_map__is_empty (cpu_list)) - cpus = is_pmu_core ?perf_cpu_map__new_online_cpus () :NULL ; -else +if (has_cpu_list) cpus =perf_cpu_map__get (cpu_list); +else + cpus = is_pmu_core ?cpu_map__online () :NULL ; }if (init_attr)event_attr_init (attr);
@@ -326,6 +327,9 @@ __add_event(struct list_head *list, int *idx,if (list)list_add_tail (&evsel->core.node, list); +if (has_cpu_list) +evsel__warn_user_requested_cpus (evsel, cpu_list); +return evsel; }
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 2/15 perf stat: Avoid buffer overflow to the aggregation map
In reply to Ian RogersCPUs may be created and passed to perf_stat__get_aggr (via config->aggr_get_id), such as in the stat display should_skip_zero_counter. There may be no such aggr_id, for example, if running with a thread. Add a missing bound check and just create IDs for these cases.
--- tools/perf/builtin-stat.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
tools/perf/builtin-stat.c +1 -1
@@ -1365,7 +1365,7 @@ static struct aggr_cpu_id perf_stat__get_aggr(struct perf_stat_config *config,struct aggr_cpu_id id;/* per-process mode - should use global aggr mode */ -if (cpu.cpu ==-1 ) +if (cpu.cpu ==-1 || cpu.cpu >= config->cpus_aggr_map->nr)return get_id (config, cpu);if (aggr_cpu_id__is_empty (&config->cpus_aggr_map->map[cpu.cpu]))
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 3/15 perf stat: Don't size aggregation ids from user_requested_cpus
In reply to Ian RogersAs evsels may have additional CPU terms, the user_requested_cpus may not reflect all the CPUs requested. Use evlist->all_cpus to size the array as that reflects all the CPUs potentially needed by the evlist.
--- tools/perf/builtin-stat.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-)
tools/perf/builtin-stat.c +2 -5
@@ -1513,11 +1513,8 @@ static int perf_stat_init_aggr_mode(void)* taking the highest cpu number to be the size of * the aggregation translate cpumap. */ -if (!perf_cpu_map__is_any_cpu_or_is_empty (evsel_list->core.user_requested_cpus)) - nr =perf_cpu_map__max (evsel_list->core.user_requested_cpus).cpu; -else - nr =0 ; - stat_config.cpus_aggr_map =cpu_aggr_map__empty_new (nr +1 ); + nr =perf_cpu_map__max (evsel_list->core.all_cpus).cpu +1 ; + stat_config.cpus_aggr_map =cpu_aggr_map__empty_new (nr);return stat_config.cpus_aggr_map ?0 : -ENOMEM ; }
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 4/15 perf parse-events: Allow the cpu term to be a PMU or CPU range
In reply to Ian RogersOn hybrid systems, events like msr/tsc/ will aggregate counts across all CPUs. Often metrics only want a value like msr/tsc/ for the cores on which the metric is being computed. Listing each CPU with terms cpu=0,cpu=1.. is laborious and would need to be encoded for all variations of a CPU model.
Allow the cpumask from a PMU to be an argument to the cpu term. For example in the following the cpumask of the cstate_pkg PMU selects the CPUs to count msr/tsc/ counter upon:
```
$ cat /sys/bus/event_source/devices/cstate_pkg/cpumask
0
$ perf stat -A -e 'msr/tsc,cpu=cstate_pkg/' -a sleep 0.1
Performance counter stats for 'system wide':
CPU0 252,621,253 msr/tsc,cpu=cstate_pkg/
0.101184092 seconds time elapsed
```As the cpu term is now also allowed to be a string, allow it to encode a range of CPUs (a list can't be supported as ',' is already a special token).
The "event qualifiers" section of the perf list man page is updated to detail the additional behavior. The man page formatting is tidied up in this section, as it was incorrectly appearing within the "parameterized events" section.
--- tools/perf/Documentation/perf-list.txt | 25 +++++++++----- tools/perf/util/parse-events.c | 47 +++++++++++++++++++++----- 2 files changed, 54 insertions(+), 18 deletions(-)
tools/perf/Documentation/perf-list.txt +16 -9
@@ -278,26 +278,33 @@ also be supplied. For example: perf stat -C 0 -e 'hv_gpci/dtbp_ptitc,phys_processor_idx=0x2/' ... -EVENT QUALIFIERS: +EVENT QUALIFIERS +---------------- It is also possible to add extra qualifiers to an event: percore: -Sums up the event counts for all hardware threads in a core, e.g.: - - - perf stat -e cpu/event=0,umask=0x3,percore=1/ + Sums up the event counts for all hardware threads in a core, e.g.: + perf stat -e cpu/event=0,umask=0x3,percore=1/ cpu: -Specifies the CPU to open the event upon. The value may be repeated to -specify opening the event on multiple CPUs: + Specifies a CPU or a range of CPUs to open the event upon. It may + also reference a PMU to copy the CPU mask from. The value may be + repeated to specify opening the event on multiple CPUs. + Example 1: to open the instructions event on CPUs 0 and 2, the + cycles event on CPUs 1 and 2: + perf stat -e instructions/cpu=0,cpu=2/,cycles/cpu=1-2/ -a sleep 1 - perf stat -e instructions/cpu=0,cpu=2/,cycles/cpu=1,cpu=2/ -a sleep 1 - perf stat -e data_read/cpu=0/,data_write/cpu=1/ -a sleep 1 + Example 2: to open the data_read uncore event on CPU 0 and the + data_write uncore event on CPU 1: + perf stat -e data_read/cpu=0/,data_write/cpu=1/ -a sleep 1 + Example 3: to open the software msr/tsc/ event only on the CPUs + matching those from the cpu_core PMU: + perf stat -e msr/tsc,cpu=cpu_core/ -a sleep 1 EVENT GROUPS ------------
tools/perf/util/parse-events.c +38 -9
63 lines not on this page · raw message
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 5/15 perf tool_pmu: Allow num_cpus(_online) to be specific to a cpumask
In reply to Ian RogersFor hybrid metrics it is useful to know the number of p-core or e-core CPUs. If a cpumask is specified for the num_cpus or num_cpus_online tool events, compute the value relative to the given mask rather than for the full system.
```
$ sudo /tmp/perf/perf stat -e 'tool/num_cpus/,tool/num_cpus,cpu=cpu_core/,
tool/num_cpus,cpu=cpu_atom/,tool/num_cpus_online/,tool/num_cpus_online,
cpu=cpu_core/,tool/num_cpus_online,cpu=cpu_atom/' true
Performance counter stats for 'true':
28 tool/num_cpus/
16 tool/num_cpus,cpu=cpu_core/
12 tool/num_cpus,cpu=cpu_atom/
28 tool/num_cpus_online/
16 tool/num_cpus_online,cpu=cpu_core/
12 tool/num_cpus_online,cpu=cpu_atom/
0.000767205 seconds time elapsed
0.000938000 seconds user
0.000000000 seconds sys
```--- tools/perf/util/expr.c | 2 +- tools/perf/util/tool_pmu.c | 56 +++++++++++++++++++++++++++++++++----- tools/perf/util/tool_pmu.h | 2 +- 3 files changed, 51 insertions(+), 9 deletions(-)
tools/perf/util/expr.c +1 -1
@@ -401,7 +401,7 @@ double expr__get_literal(const char *literal, const struct expr_scanner_ctx *ctxif (ev !=TOOL_PMU__EVENT_NONE ) {u64 count; -if (tool_pmu__read_event (ev, &count)) +if (tool_pmu__read_event (ev,/*evsel=*/ NULL , &count)) result = count;else pr_err ("Failure to read '%s'" , literal);
tools/perf/util/tool_pmu.c +49 -7
81 lines not on this page · raw message
tools/perf/util/tool_pmu.h +1 -1
@@ -34,7 +34,7 @@ enum tool_pmu_event tool_pmu__str_to_event(const char *str);bool tool_pmu__skip_event (const char *name);int tool_pmu__num_skip_events (void ); -bool tool_pmu__read_event (enum tool_pmu_event ev,u64 *result); +bool tool_pmu__read_event (enum tool_pmu_event ev,struct evsel *evsel,u64 *result);u64 tool_pmu__cpu_slots_per_cycle (void );
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 6/15 libperf evsel: Rename own_cpus to pmu_cpus
In reply to Ian Rogersown_cpus is generally the cpumask from the PMU. Rename to pmu_cpus to try to make this clearer. Variable rename with no other changes.
--- tools/lib/perf/evlist.c | 8 ++++---- tools/lib/perf/evsel.c | 2 +- tools/lib/perf/include/internal/evsel.h | 2 +- tools/perf/tests/event_update.c | 4 ++-- tools/perf/util/evsel.c | 6 +++--- tools/perf/util/header.c | 4 ++-- tools/perf/util/parse-events.c | 2 +- tools/perf/util/synthetic-events.c | 4 ++-- tools/perf/util/tool_pmu.c | 12 ++++++------ 9 files changed, 22 insertions(+), 22 deletions(-)
tools/lib/perf/evlist.c +4 -4
@@ -46,7 +46,7 @@ static void __perf_evlist__propagate_maps(struct perf_evlist *evlist,* are valid by intersecting with those of the PMU. */ perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__intersect (evlist->user_requested_cpus, evsel->own_cpus); + evsel->cpus =perf_cpu_map__intersect (evlist->user_requested_cpus, evsel->pmu_cpus);/* * Empty cpu lists would eventually get opened as "any" so remove
@@ -61,7 +61,7 @@ static void __perf_evlist__propagate_maps(struct perf_evlist *evlist,list_for_each_entry_from (next, &evlist->entries, node) next->idx--; } - }else if (!evsel->own_cpus || evlist->has_user_cpus || + }else if (!evsel->pmu_cpus || evlist->has_user_cpus || (!evsel->requires_cpu &&perf_cpu_map__has_any_cpu (evlist->user_requested_cpus))) {/* * The PMU didn't specify a default cpu map, this isn't a core
@@ -72,13 +72,13 @@ static void __perf_evlist__propagate_maps(struct perf_evlist *evlist,*/ perf_cpu_map__put (evsel->cpus); evsel->cpus =perf_cpu_map__get (evlist->user_requested_cpus); - }else if (evsel->cpus != evsel->own_cpus) { + }else if (evsel->cpus != evsel->pmu_cpus) {/* * No user requested cpu map but the PMU cpu map doesn't match * the evsel's. Reset it back to the PMU cpu map. */ perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__get (evsel->own_cpus); + evsel->cpus =perf_cpu_map__get (evsel->pmu_cpus); }if (evsel->system_wide) {
tools/lib/perf/evsel.c +1 -1
@@ -46,7 +46,7 @@ void perf_evsel__delete(struct perf_evsel *evsel)assert (evsel->mmap ==NULL );/* If not munmap wasn't called. */ assert (evsel->sample_id ==NULL );/* If not free_id wasn't called. */ perf_cpu_map__put (evsel->cpus); -perf_cpu_map__put (evsel->own_cpus); +perf_cpu_map__put (evsel->pmu_cpus);perf_thread_map__put (evsel->threads);free (evsel); }
tools/lib/perf/include/internal/evsel.h +1 -1
@@ -99,7 +99,7 @@ struct perf_evsel {* cpu map for opening the event on, for example, the first CPU on a * socket for an uncore event. */ -struct perf_cpu_map *own_cpus; +struct perf_cpu_map *pmu_cpus;struct perf_thread_map *threads;struct xyarray *fd;struct xyarray *mmap;
tools/perf/tests/event_update.c +2 -2
@@ -109,8 +109,8 @@ static int test__event_update(struct test_suite *test __maybe_unused, int subtesTEST_ASSERT_VAL ("failed to synthesize attr update name" , !perf_event__synthesize_event_update_name (&tmp.tool, evsel, process_event_name)); -perf_cpu_map__put (evsel->core.own_cpus); - evsel->core.own_cpus =perf_cpu_map__new ("1,2,3" ); +perf_cpu_map__put (evsel->core.pmu_cpus); + evsel->core.pmu_cpus =perf_cpu_map__new ("1,2,3" );TEST_ASSERT_VAL ("failed to synthesize attr update cpus" , !perf_event__synthesize_event_update_cpus (&tmp.tool, evsel, process_event_cpus));
tools/perf/util/evsel.c +3 -3
@@ -488,7 +488,7 @@ struct evsel *evsel__clone(struct evsel *dest, struct evsel *orig)return NULL ; evsel->core.cpus =perf_cpu_map__get (orig->core.cpus); - evsel->core.own_cpus =perf_cpu_map__get (orig->core.own_cpus); + evsel->core.pmu_cpus =perf_cpu_map__get (orig->core.pmu_cpus); evsel->core.threads =perf_thread_map__get (orig->core.threads); evsel->core.nr_members = orig->core.nr_members; evsel->core.system_wide = orig->core.system_wide;
@@ -1527,7 +1527,7 @@ void evsel__config(struct evsel *evsel, struct record_opts *opts, attr->exclude_user =1 ; } -if (evsel->core.own_cpus || evsel->unit) +if (evsel->core.pmu_cpus || evsel->unit) evsel->core.attr.read_format |=PERF_FORMAT_ID ;/*
@@ -1680,7 +1680,7 @@ void evsel__exit(struct evsel *evsel)evsel__free_config_terms (evsel);cgroup__put (evsel->cgrp);perf_cpu_map__put (evsel->core.cpus); -perf_cpu_map__put (evsel->core.own_cpus); +perf_cpu_map__put (evsel->core.pmu_cpus);perf_thread_map__put (evsel->core.threads);zfree (&evsel->group_name);zfree (&evsel->name);
tools/perf/util/header.c +2 -2
@@ -4507,8 +4507,8 @@ int perf_event__process_event_update(const struct perf_tool *tool __maybe_unusedcase PERF_EVENT_UPDATE__CPUS : map =cpu_map__new_data (&ev->cpus.cpus);if (map) { -perf_cpu_map__put (evsel->core.own_cpus); - evsel->core.own_cpus = map; +perf_cpu_map__put (evsel->core.pmu_cpus); + evsel->core.pmu_cpus = map; }else pr_err ("failed to get event_update cpus\n" );default :
tools/perf/util/parse-events.c +1 -1
@@ -320,7 +320,7 @@ __add_event(struct list_head *list, int *idx, (*idx)++; evsel->core.cpus = cpus; - evsel->core.own_cpus =perf_cpu_map__get (cpus); + evsel->core.pmu_cpus =perf_cpu_map__get (cpus); evsel->core.requires_cpu = pmu ? pmu->is_uncore : false; evsel->core.is_pmu_core = is_pmu_core; evsel->pmu = pmu;
tools/perf/util/synthetic-events.c +2 -2
@@ -2045,7 +2045,7 @@ int perf_event__synthesize_event_update_name(const struct perf_tool *tool, strucint perf_event__synthesize_event_update_cpus (const struct perf_tool *tool,struct evsel *evsel,perf_event__handler_t process) { -struct synthesize_cpu_map_data syn_data = { .map = evsel->core.own_cpus }; +struct synthesize_cpu_map_data syn_data = { .map = evsel->core.pmu_cpus };struct perf_record_event_update *ev;int err;
@@ -2126,7 +2126,7 @@ int perf_event__synthesize_extra_attr(const struct perf_tool *tool, struct evlis } } -if (evsel->core.own_cpus) { +if (evsel->core.pmu_cpus) { err =perf_event__synthesize_event_update_cpus (tool, evsel, process);if (err <0 ) {pr_err ("Couldn't synthesize evsel cpus.\n" );
tools/perf/util/tool_pmu.c +6 -6
@@ -357,10 +357,10 @@ bool tool_pmu__read_event(enum tool_pmu_event ev, struct evsel *evsel, u64 *resu/* * "Any CPU" event that can be scheduled on any CPU in * the PMU's cpumask. The PMU cpumask should be saved in -* own_cpus. If not present fall back to max. +* pmu_cpus. If not present fall back to max. */ -if (!perf_cpu_map__is_empty (evsel->core.own_cpus)) - *result =perf_cpu_map__nr (evsel->core.own_cpus); +if (!perf_cpu_map__is_empty (evsel->core.pmu_cpus)) + *result =perf_cpu_map__nr (evsel->core.pmu_cpus);else *result =cpu__max_present_cpu ().cpu; }
@@ -386,12 +386,12 @@ bool tool_pmu__read_event(enum tool_pmu_event ev, struct evsel *evsel, u64 *resu/* * "Any CPU" event that can be scheduled on any CPU in * the PMU's cpumask. The PMU cpumask should be saved in -* own_cpus, if not present then just the online cpu +* pmu_cpus, if not present then just the online cpu * mask. */ -if (!perf_cpu_map__is_empty (evsel->core.own_cpus)) { +if (!perf_cpu_map__is_empty (evsel->core.pmu_cpus)) {struct perf_cpu_map *tmp = -perf_cpu_map__intersect (online, evsel->core.own_cpus); +perf_cpu_map__intersect (online, evsel->core.pmu_cpus); *result =perf_cpu_map__nr (tmp);perf_cpu_map__put (tmp);
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 7/15 libperf evsel: Factor perf_evsel__exit out of perf_evsel__delete
In reply to Ian RogersThis allows the perf_evsel__exit to be called when the struct perf_evsel is embedded inside another struct, such as struct evsel in perf.
--- tools/lib/perf/evsel.c | 7 ++++++- tools/lib/perf/include/internal/evsel.h | 1 + 2 files changed, 7 insertions(+), 1 deletion(-)
tools/lib/perf/evsel.c +6 -1
@@ -40,7 +40,7 @@ struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr)return evsel; } -void perf_evsel__delete (struct perf_evsel *evsel) +void perf_evsel__exit (struct perf_evsel *evsel) {assert (evsel->fd ==NULL );/* If not fds were not closed. */ assert (evsel->mmap ==NULL );/* If not munmap wasn't called. */
@@ -48,6 +48,11 @@ void perf_evsel__delete(struct perf_evsel *evsel)perf_cpu_map__put (evsel->cpus);perf_cpu_map__put (evsel->pmu_cpus);perf_thread_map__put (evsel->threads); +} + +void perf_evsel__delete (struct perf_evsel *evsel) +{ +perf_evsel__exit (evsel);free (evsel); }
tools/lib/perf/include/internal/evsel.h +1 -0
@@ -133,6 +133,7 @@ struct perf_evsel {void perf_evsel__init (struct perf_evsel *evsel,struct perf_event_attr *attr,int idx); +void perf_evsel__exit (struct perf_evsel *evsel);int perf_evsel__alloc_fd (struct perf_evsel *evsel,int ncpus,int nthreads);void perf_evsel__close_fd (struct perf_evsel *evsel);void perf_evsel__free_fd (struct perf_evsel *evsel);
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 8/15 perf evsel: Use libperf perf_evsel__exit
In reply to Ian RogersAvoid the duplicated code and better enable perf_evsel to change.
--- tools/perf/util/evsel.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
tools/perf/util/evsel.c +1 -3
@@ -1679,9 +1679,7 @@ void evsel__exit(struct evsel *evsel)perf_evsel__free_id (&evsel->core);evsel__free_config_terms (evsel);cgroup__put (evsel->cgrp); -perf_cpu_map__put (evsel->core.cpus); -perf_cpu_map__put (evsel->core.pmu_cpus); -perf_thread_map__put (evsel->core.threads); +perf_evsel__exit (&evsel->core);zfree (&evsel->group_name);zfree (&evsel->name);#ifdef HAVE_LIBTRACEEVENT
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 9/15 perf pmus: Factor perf_pmus__find_by_attr out of evsel__find_pmu
In reply to Ian RogersAllow a PMU to be found by a perf_event_attr, useful when creating evsels.
--- tools/perf/util/pmus.c | 29 +++++++++++++++++------------ tools/perf/util/pmus.h | 2 ++ 2 files changed, 19 insertions(+), 12 deletions(-)
tools/perf/util/pmus.c +17 -12
@@ -814,24 +814,18 @@ bool perf_pmus__supports_extended_type(void)return perf_pmus__do_support_extended_type; } -struct perf_pmu *evsel__find_pmu (const struct evsel *evsel) +struct perf_pmu *perf_pmus__find_by_attr (const struct perf_event_attr *attr) { -struct perf_pmu *pmu = evsel->pmu; -bool legacy_core_type; - -if (pmu) -return pmu; +struct perf_pmu *pmu =perf_pmus__find_by_type (attr->type); +u32 type = attr->type; +bool legacy_core_type = type ==PERF_TYPE_HARDWARE || type ==PERF_TYPE_HW_CACHE ; - pmu =perf_pmus__find_by_type (evsel->core.attr.type); - legacy_core_type = - evsel->core.attr.type ==PERF_TYPE_HARDWARE || - evsel->core.attr.type ==PERF_TYPE_HW_CACHE ;if (!pmu && legacy_core_type &&perf_pmus__supports_extended_type ()) { -u32 type = evsel->core.attr.config >>PERF_PMU_TYPE_SHIFT ; + type = attr->config >>PERF_PMU_TYPE_SHIFT ; pmu =perf_pmus__find_by_type (type); } -if (!pmu && (legacy_core_type || evsel->core.attr.type ==PERF_TYPE_RAW )) { +if (!pmu && (legacy_core_type || type ==PERF_TYPE_RAW )) {/* * For legacy events, if there was no extended type info then * assume the PMU is the first core PMU.
@@ -842,6 +836,17 @@ struct perf_pmu *evsel__find_pmu(const struct evsel *evsel)*/ pmu =perf_pmus__find_core_pmu (); } +return pmu; +} + +struct perf_pmu *evsel__find_pmu (const struct evsel *evsel) +{ +struct perf_pmu *pmu = evsel->pmu; + +if (pmu) +return pmu; + + pmu =perf_pmus__find_by_attr (&evsel->core.attr); ((struct evsel *)evsel)->pmu = pmu;return pmu; }
tools/perf/util/pmus.h +2 -0
@@ -5,6 +5,7 @@#include <stdbool.h> #include <stddef.h> +struct perf_event_attr ;struct perf_pmu ;struct print_callbacks ;
@@ -16,6 +17,7 @@ void perf_pmus__destroy(void);struct perf_pmu *perf_pmus__find (const char *name);struct perf_pmu *perf_pmus__find_by_type (unsigned int type); +struct perf_pmu *perf_pmus__find_by_attr (const struct perf_event_attr *attr);struct perf_pmu *perf_pmus__scan (struct perf_pmu *pmu);struct perf_pmu *perf_pmus__scan_core (struct perf_pmu *pmu);
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 10/15 perf parse-events: Minor __add_event refactoring
In reply to Ian RogersRename cpu_list to user_cpus. If a PMU isn't given, find it early from the perf_event_attr. Make the pmu_cpus more explicitly a copy from the PMU (except when user_cpus are given). Derive the cpus from pmu_cpus and user_cpus as appropriate. Handle strdup errors on name and metric_id.
--- tools/perf/util/parse-events.c | 69 +++++++++++++++++++++++----------- 1 file changed, 48 insertions(+), 21 deletions(-)
tools/perf/util/parse-events.c +48 -21
@@ -259,12 +259,12 @@ __add_event(struct list_head *list, int *idx,bool init_attr, const char *name, const char *metric_id, struct perf_pmu *pmu, struct list_head *config_terms, struct evsel *first_wildcard_match, - struct perf_cpu_map *cpu_list, u64 alternate_hw_config) + struct perf_cpu_map *user_cpus, u64 alternate_hw_config) { struct evsel *evsel;bool is_pmu_core; -struct perf_cpu_map *cpus; -bool has_cpu_list = !perf_cpu_map__is_empty (cpu_list); +struct perf_cpu_map *cpus, *pmu_cpus; +bool has_user_cpus = !perf_cpu_map__is_empty (user_cpus);/* * Ensure the first_wildcard_match's PMU matches that of the new event
@@ -288,8 +288,6 @@ __add_event(struct list_head *list, int *idx, }if (pmu) { - is_pmu_core = pmu->is_core; - cpus =perf_cpu_map__get (has_cpu_list ? cpu_list : pmu->cpus);perf_pmu__warn_invalid_formats (pmu);if (attr->type ==PERF_TYPE_RAW || attr->type >=PERF_TYPE_MAX ) { perf_pmu__warn_invalid_config(pmu, attr->config, name,
@@ -301,48 +299,77 @@ __add_event(struct list_head *list, int *idx,perf_pmu__warn_invalid_config (pmu, attr->config3, name,PERF_PMU_FORMAT_VALUE_CONFIG3 ,"config3" ); } + } +/* +* If a PMU wasn't given, such as for legacy events, find now that +* warnings won't be generated. +*/ +if (!pmu) + pmu =perf_pmus__find_by_attr (attr); + +if (pmu) { + is_pmu_core = pmu->is_core; + pmu_cpus =perf_cpu_map__get (pmu->cpus); }else { is_pmu_core = (attr->type ==PERF_TYPE_HARDWARE || attr->type ==PERF_TYPE_HW_CACHE ); -if (has_cpu_list) - cpus =perf_cpu_map__get (cpu_list); -else - cpus = is_pmu_core ?cpu_map__online () :NULL ; + pmu_cpus = is_pmu_core ?cpu_map__online () :NULL ; + } + +if (has_user_cpus) { + cpus =perf_cpu_map__get (user_cpus); +/* Existing behavior that pmu_cpus matches the given user ones. */ +perf_cpu_map__put (pmu_cpus); + pmu_cpus =perf_cpu_map__get (user_cpus); + }else { + cpus =perf_cpu_map__get (pmu_cpus); } +if (init_attr)event_attr_init (attr); evsel =evsel__new_idx (attr, *idx); -if (!evsel) { -perf_cpu_map__put (cpus); -return NULL ; +if (!evsel) + goto out_err; + +if (name) { + evsel->name =strdup (name); +if (!evsel->name) + goto out_err; + } + +if (metric_id) { + evsel->metric_id =strdup (metric_id); +if (!evsel->metric_id) + goto out_err; } (*idx)++; evsel->core.cpus = cpus; - evsel->core.pmu_cpus =perf_cpu_map__get (cpus); + evsel->core.pmu_cpus = pmu_cpus; evsel->core.requires_cpu = pmu ? pmu->is_uncore : false; evsel->core.is_pmu_core = is_pmu_core; evsel->pmu = pmu; evsel->alternate_hw_config = alternate_hw_config; evsel->first_wildcard_match = first_wildcard_match; -if (name) - evsel->name =strdup (name); - -if (metric_id) - evsel->metric_id =strdup (metric_id); -if (config_terms)list_splice_init (config_terms, &evsel->config_terms);if (list)list_add_tail (&evsel->core.node, list); -if (has_cpu_list) -evsel__warn_user_requested_cpus (evsel, cpu_list); +if (has_user_cpus) +evsel__warn_user_requested_cpus (evsel, user_cpus);return evsel; +out_err: +perf_cpu_map__put (cpus); +perf_cpu_map__put (pmu_cpus); +zfree (&evsel->name); +zfree (&evsel->metric_id); +free (evsel); +return NULL ; } struct evsel *parse_events__add_event(int idx, struct perf_event_attr *attr,
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 11/15 perf evsel: Add evsel__open_per_cpu_and_thread
In reply to Ian RogersAdd evsel__open_per_cpu_and_thread that combines the operation of evsel__open_per_cpu and evsel__open_per_thread so that an event without the "any" cpumask can be opened with its cpumask and with threads it specifies. Change the implementation of evsel__open_per_cpu and evsel__open_per_thread to use evsel__open_per_cpu_and_thread to make the implementation of those functions clearer.
--- tools/perf/util/evsel.c | 23 +++++++++++++++++++---- tools/perf/util/evsel.h | 3 +++ 2 files changed, 22 insertions(+), 4 deletions(-)
tools/perf/util/evsel.c +19 -4
@@ -2761,17 +2761,32 @@ void evsel__close(struct evsel *evsel)perf_evsel__free_id (&evsel->core); } -int evsel__open_per_cpu (struct evsel *evsel,struct perf_cpu_map *cpus,int cpu_map_idx) +int evsel__open_per_cpu_and_thread (struct evsel *evsel, +struct perf_cpu_map *cpus,int cpu_map_idx, +struct perf_thread_map *threads) {if (cpu_map_idx ==-1 ) -return evsel__open_cpu (evsel, cpus,NULL ,0 ,perf_cpu_map__nr (cpus)); +return evsel__open_cpu (evsel, cpus, threads,0 ,perf_cpu_map__nr (cpus)); -return evsel__open_cpu (evsel, cpus,NULL , cpu_map_idx, cpu_map_idx +1 ); +return evsel__open_cpu (evsel, cpus, threads, cpu_map_idx, cpu_map_idx +1 ); +} + +int evsel__open_per_cpu (struct evsel *evsel,struct perf_cpu_map *cpus,int cpu_map_idx) +{ +struct perf_thread_map *threads =thread_map__new_by_tid (-1 ); +int ret =evsel__open_per_cpu_and_thread (evsel, cpus, cpu_map_idx, threads); + +perf_thread_map__put (threads); +return ret; }int evsel__open_per_thread (struct evsel *evsel,struct perf_thread_map *threads) { -return evsel__open (evsel,NULL , threads); +struct perf_cpu_map *cpus =perf_cpu_map__new_any_cpu (); +int ret =evsel__open_per_cpu_and_thread (evsel, cpus,-1 , threads); + +perf_cpu_map__put (cpus); +return ret; } static int perf_evsel__parse_id_sample(const struct evsel *evsel,
tools/perf/util/evsel.h +3 -0
@@ -351,6 +351,9 @@ int evsel__enable(struct evsel *evsel);int evsel__disable (struct evsel *evsel);int evsel__disable_cpu (struct evsel *evsel,int cpu_map_idx); +int evsel__open_per_cpu_and_thread (struct evsel *evsel, +struct perf_cpu_map *cpus,int cpu_map_idx, +struct perf_thread_map *threads);int evsel__open_per_cpu (struct evsel *evsel,struct perf_cpu_map *cpus,int cpu_map_idx);int evsel__open_per_thread (struct evsel *evsel,struct perf_thread_map *threads); int evsel__open(struct evsel *evsel, struct perf_cpu_map *cpus,
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 12/15 perf parse-events: Support user CPUs mixed with threads/processes
In reply to Ian RogersCounting events system-wide with a specified CPU prior to this change worked:
```
$ perf stat -e 'msr/tsc/,msr/tsc,cpu=cpu_core/,msr/tsc,cpu=cpu_atom/' -a sleep 1
Performance counter stats for 'system wide':
59,393,419,099 msr/tsc/
33,927,965,927 msr/tsc,cpu=cpu_core/
25,465,608,044 msr/tsc,cpu=cpu_atom/
```However, when counting with process the counts became system wide:
```
$ perf stat -e 'msr/tsc/,msr/tsc,cpu=cpu_core/,msr/tsc,cpu=cpu_atom/' perf test -F 10
10.1: Basic parsing test : Ok
10.2: Parsing without PMU name : Ok
10.3: Parsing with PMU name : Ok
Performance counter stats for 'perf test -F 10':
59,233,549 msr/tsc/
59,227,556 msr/tsc,cpu=cpu_core/
59,224,053 msr/tsc,cpu=cpu_atom/
```Make the handling of CPU maps with event parsing clearer. When an event is parsed creating an evsel the cpus should be either the PMU's cpumask or user specified CPUs.
Update perf_evlist__propagate_maps so that it doesn't clobber the user specified CPUs. Try to make the behavior clearer, firstly fix up missing cpumasks. Next, perform sanity checks and adjustments from the global evlist CPU requests and for the PMU including simplifying to the "any CPU"(-1) value. Finally remove the event if the cpumask is empty.
So that events are opened with a CPU and a thread change stat's create_perf_stat_counter to give both.
With the change things are fixed:
```
$ perf stat --no-scale -e 'msr/tsc/,msr/tsc,cpu=cpu_core/,msr/tsc,cpu=cpu_atom/' perf test -F 10
10.1: Basic parsing test : Ok
10.2: Parsing without PMU name : Ok
10.3: Parsing with PMU name : Ok
Performance counter stats for 'perf test -F 10':
63,704,975 msr/tsc/
47,060,704 msr/tsc,cpu=cpu_core/ (4.62%)
16,640,591 msr/tsc,cpu=cpu_atom/ (2.18%)
```However, note the "--no-scale" option is used. This is necessary as the running time for the event on the counter isn't the same as the enabled time because the thread doesn't necessarily run on the CPUs specified for the counter. All counter values are scaled with:
scaled_value = value * time_enabled / time_running
and so without --no-scale the scaled_value becomes very large. This problem already exists on hybrid systems for the same reason. Here are 2 runs of the same code with an instructions event that counts the same on both types of core, there is no real multiplexing happening on the event:
```
$ perf stat -e instructions perf test -F 10
...
Performance counter stats for 'perf test -F 10':
87,896,447 cpu_atom/instructions/ (14.37%)
98,171,964 cpu_core/instructions/ (85.63%)
...
$ perf stat --no-scale -e instructions perf test -F 10
...
Performance counter stats for 'perf test -F 10':
13,069,890 cpu_atom/instructions/ (19.32%)
83,460,274 cpu_core/instructions/ (80.68%)
...
```The scaling has inflated per-PMU instruction counts and the overall count by 2x.
To fix this the kernel needs changing when a task+CPU event (or just task event on hybrid) is scheduled out. A fix could be that the state isn't inactive but off for such events, so that time_enabled counts don't accumulate on them.
--- tools/lib/perf/evlist.c | 119 ++++++++++++++++++++++----------- tools/perf/util/parse-events.c | 10 ++- tools/perf/util/stat.c | 6 +- 3 files changed, 87 insertions(+), 48 deletions(-)
tools/lib/perf/evlist.c +81 -38
@@ -36,49 +36,88 @@ void perf_evlist__init(struct perf_evlist *evlist)static void __perf_evlist__propagate_maps (struct perf_evlist *evlist,struct perf_evsel *evsel) { -if (evsel->system_wide) { -/* System wide: set the cpu map of the evsel to all online CPUs. */ -perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__new_online_cpus (); - }else if (evlist->has_user_cpus && evsel->is_pmu_core) { -/* -* User requested CPUs on a core PMU, ensure the requested CPUs -* are valid by intersecting with those of the PMU. -*/ +if (perf_cpu_map__is_empty (evsel->cpus)) { +if (perf_cpu_map__is_empty (evsel->pmu_cpus)) { +/* +* Assume the unset PMU cpus were for a system-wide +* event, like a software or tracepoint. +*/ + evsel->pmu_cpus =perf_cpu_map__new_online_cpus (); + } +if (evlist->has_user_cpus && !evsel->system_wide) { +/* +* Use the user CPUs unless the evsel is set to be +* system wide, such as the dummy event. +*/ + evsel->cpus =perf_cpu_map__get (evlist->user_requested_cpus); + }else { +/* +* System wide and other modes, assume the cpu map +* should be set to all PMU CPUs. +*/ + evsel->cpus =perf_cpu_map__get (evsel->pmu_cpus); + } + } +/* +* Avoid "any CPU"(-1) for uncore and PMUs that require a CPU, even if +* requested. +*/ +if (evsel->requires_cpu &&perf_cpu_map__has_any_cpu (evsel->cpus)) {perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__intersect (evlist->user_requested_cpus, evsel->pmu_cpus); + evsel->cpus =perf_cpu_map__get (evsel->pmu_cpus); + } -/* -* Empty cpu lists would eventually get opened as "any" so remove -* genuinely empty ones before they're opened in the wrong place. -*/ -if (perf_cpu_map__is_empty (evsel->cpus)) { -struct perf_evsel *next =perf_evlist__next (evlist, evsel); - -perf_evlist__remove (evlist, evsel); -/* Keep idx contiguous */ -if (next) -list_for_each_entry_from (next, &evlist->entries, node) - next->idx--; +/* +* Globally requested CPUs replace user requested unless the evsel is +* set to be system wide. +*/ +if (evlist->has_user_cpus && !evsel->system_wide) { +assert (!perf_cpu_map__has_any_cpu (evlist->user_requested_cpus)); +if (!perf_cpu_map__equal (evsel->cpus, evlist->user_requested_cpus)) { +perf_cpu_map__put (evsel->cpus); + evsel->cpus =perf_cpu_map__get (evlist->user_requested_cpus); } - }else if (!evsel->pmu_cpus || evlist->has_user_cpus || - (!evsel->requires_cpu &&perf_cpu_map__has_any_cpu (evlist->user_requested_cpus))) { -/* -* The PMU didn't specify a default cpu map, this isn't a core -* event and the user requested CPUs or the evlist user -* requested CPUs have the "any CPU" (aka dummy) CPU value. In -* which case use the user requested CPUs rather than the PMU -* ones. -*/ + } + +/* Ensure cpus only references valid PMU CPUs. */ +if (!perf_cpu_map__has_any_cpu (evsel->cpus) && + !perf_cpu_map__is_subset (evsel->pmu_cpus, evsel->cpus)) { +struct perf_cpu_map *tmp =perf_cpu_map__intersect (evsel->pmu_cpus, evsel->cpus); +perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__get (evlist->user_requested_cpus); - }else if (evsel->cpus != evsel->pmu_cpus) { -/* -* No user requested cpu map but the PMU cpu map doesn't match -* the evsel's. Reset it back to the PMU cpu map. -*/ + evsel->cpus = tmp; + } + +/* +* Was event requested on all the PMU's CPUs but the user requested is +* any CPU (-1)? If so switch to using any CPU (-1) to reduce the number +* of events. +*/ +if (!evsel->system_wide && + !evsel->requires_cpu && +perf_cpu_map__equal (evsel->cpus, evsel->pmu_cpus) && +perf_cpu_map__has_any_cpu (evlist->user_requested_cpus)) {perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__get (evsel->pmu_cpus); + evsel->cpus =perf_cpu_map__get (evlist->user_requested_cpus); + } + +/* Sanity check assert before the evsel is potentially removed. */ +assert (!evsel->requires_cpu || !perf_cpu_map__has_any_cpu (evsel->cpus)); + +/* +* Empty cpu lists would eventually get opened as "any" so remove +* genuinely empty ones before they're opened in the wrong place. +*/ +if (perf_cpu_map__is_empty (evsel->cpus)) { +struct perf_evsel *next =perf_evlist__next (evlist, evsel); + +perf_evlist__remove (evlist, evsel); +/* Keep idx contiguous */ +if (next) +list_for_each_entry_from (next, &evlist->entries, node) + next->idx--; + +return ; }if (evsel->system_wide) {
@@ -98,6 +137,10 @@ static void perf_evlist__propagate_maps(struct perf_evlist *evlist) evlist->needs_map_propagation = true; +/* Clear the all_cpus set which will be merged into during propagation. */ +perf_cpu_map__put (evlist->all_cpus); + evlist->all_cpus =NULL ; +list_for_each_entry_safe (evsel, n, &evlist->entries, node)__perf_evlist__propagate_maps (evlist, evsel); }
tools/perf/util/parse-events.c +4 -6
@@ -310,20 +310,18 @@ __add_event(struct list_head *list, int *idx,if (pmu) { is_pmu_core = pmu->is_core; pmu_cpus =perf_cpu_map__get (pmu->cpus); +if (perf_cpu_map__is_empty (pmu_cpus)) + pmu_cpus =cpu_map__online (); }else { is_pmu_core = (attr->type ==PERF_TYPE_HARDWARE || attr->type ==PERF_TYPE_HW_CACHE ); pmu_cpus = is_pmu_core ?cpu_map__online () :NULL ; } -if (has_user_cpus) { +if (has_user_cpus) cpus =perf_cpu_map__get (user_cpus); -/* Existing behavior that pmu_cpus matches the given user ones. */ -perf_cpu_map__put (pmu_cpus); - pmu_cpus =perf_cpu_map__get (user_cpus); - }else { +else cpus =perf_cpu_map__get (pmu_cpus); - }if (init_attr)event_attr_init (attr);
tools/perf/util/stat.c +2 -4
@@ -769,8 +769,6 @@ int create_perf_stat_counter(struct evsel *evsel, attr->enable_on_exec =1 ; } -if (target__has_cpu (target) && !target__has_per_thread (target)) -return evsel__open_per_cpu (evsel,evsel__cpus (evsel), cpu_map_idx); - -return evsel__open_per_thread (evsel, evsel->core.threads); +return evsel__open_per_cpu_and_thread (evsel,evsel__cpus (evsel), cpu_map_idx, + evsel->core.threads); }
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerRe: [PATCH v3 12/15] perf parse-events: Support user CPUs mixed with threads/processes
Quoted 114 lines · Ian Rogers
Counting events system-wide with a specified CPU prior to this change worked:
``` $ perf stat -e 'msr/tsc/,msr/tsc,cpu=cpu_core/,msr/tsc,cpu=cpu_atom/' -a sleep 1 Performance counter stats for 'system wide': 59,393,419,099 msr/tsc/ 33,927,965,927 msr/tsc,cpu=cpu_core/ 25,465,608,044 msr/tsc,cpu=cpu_atom/ ```However, when counting with process the counts became system wide:
``` $ perf stat -e 'msr/tsc/,msr/tsc,cpu=cpu_core/,msr/tsc,cpu=cpu_atom/' perf test -F 10 10.1: Basic parsing test : Ok 10.2: Parsing without PMU name : Ok 10.3: Parsing with PMU name : Ok Performance counter stats for 'perf test -F 10': 59,233,549 msr/tsc/ 59,227,556 msr/tsc,cpu=cpu_core/ 59,224,053 msr/tsc,cpu=cpu_atom/ ```Make the handling of CPU maps with event parsing clearer. When an event is parsed creating an evsel the cpus should be either the PMU's cpumask or user specified CPUs.
Update
perf_evlist__propagate_mapsso that it doesn't clobber the user specified CPUs. Try to make the behavior clearer, firstly fix up missing cpumasks. Next, perform sanity checks and adjustments from the global evlist CPU requests and for the PMU including simplifying to the "any CPU"(-1) value. Finally remove the event if the cpumask is empty.So that events are opened with a CPU and a thread change stat's
create_perf_stat_counterto give both.With the change things are fixed:
``` $ perf stat --no-scale -e 'msr/tsc/,msr/tsc,cpu=cpu_core/,msr/tsc,cpu=cpu_atom/' perf test -F 10 10.1: Basic parsing test : Ok 10.2: Parsing without PMU name : Ok 10.3: Parsing with PMU name : Ok Performance counter stats for 'perf test -F 10': 63,704,975 msr/tsc/ 47,060,704 msr/tsc,cpu=cpu_core/ (4.62%) 16,640,591 msr/tsc,cpu=cpu_atom/ (2.18%) ```However, note the "--no-scale" option is used. This is necessary as the running time for the event on the counter isn't the same as the enabled time because the thread doesn't necessarily run on the CPUs specified for the counter. All counter values are scaled with:
scaled_value= value *time_enabled/time_runningand so without --no-scale the
scaled_valuebecomes very large. This problem already exists on hybrid systems for the same reason. Here are 2 runs of the same code with an instructions event that counts the same on both types of core, there is no real multiplexing happening on the event:``` $ perf stat -e instructions perf test -F 10 ... Performance counter stats for 'perf test -F 10': 87,896,447 cpu_atom/instructions/ (14.37%) 98,171,964 cpu_core/instructions/ (85.63%) ... $ perf stat --no-scale -e instructions perf test -F 10 ... Performance counter stats for 'perf test -F 10': 13,069,890 cpu_atom/instructions/ (19.32%) 83,460,274 cpu_core/instructions/ (80.68%) ... ```The scaling has inflated per-PMU instruction counts and the overall count by 2x.
To fix this the kernel needs changing when a task+CPU event (or just task event on hybrid) is scheduled out. A fix could be that the state isn't inactive but off for such events, so that
time_enabledcounts don't accumulate on them.Reviewed-by Thomas Falcon <[email protected]>Signed-off-by Ian Rogers <[email protected]>--- tools/lib/perf/evlist.c | 119 ++++++++++++++++++++++----------- tools/perf/util/parse-events.c | 10 ++- tools/perf/util/stat.c | 6 +- 3 files changed, 87 insertions(+), 48 deletions(-)tools/lib/perf/evlist.c +0
-6@@ -36,49 +36,88 @@ void perf_evlist__init(struct perf_evlist *evlist)static void __perf_evlist__propagate_maps (struct perf_evlist *evlist,struct perf_evsel *evsel) { -if (evsel->system_wide) { -/* System wide: set the cpu map of the evsel to all online CPUs. */ -perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__new_online_cpus (); - }else if (evlist->has_user_cpus && evsel->is_pmu_core) { -/*
tools/lib/perf/evlist.c void perf_evlist__init(struct perf_evlist *evlist) · line 45
Quoted 10 lines
tools/lib/perf/evlist.c +7
-3-* User requested CPUs on a core PMU, ensure the requested CPUs -* are valid by intersecting with those of the PMU. -*/ +if (perf_cpu_map__is_empty (evsel->cpus)) { +if (perf_cpu_map__is_empty (evsel->pmu_cpus)) { +/* +* Assume the unset PMU cpus were for a system-wide +* event, like a software or tracepoint. +*/ + evsel->pmu_cpus =perf_cpu_map__new_online_cpus ();
Note, I'd like to follow this change up and remove the code above. This isn't currently possible because of the assumptions of software events. It is possible for a PMU to have an empty cpumask in a situation like a hybrid machine and you've made all of one core type off-line. By making this case be all online CPUs then the offline PMU's events (say cpu_atom) can end up trying to be programmed on the online PMU's CPUs (say cpu_core) and fail at perf_event_open. This can easily happen for metrics that are defined on both core types.
Thanks,
Ian
Quoted 165 lines
tools/lib/perf/evlist.c +74
-29+ } +if (evlist->has_user_cpus && !evsel->system_wide) { +/* +* Use the user CPUs unless the evsel is set to be +* system wide, such as the dummy event. +*/ + evsel->cpus =perf_cpu_map__get (evlist->user_requested_cpus); + }else { +/* +* System wide and other modes, assume the cpu map +* should be set to all PMU CPUs. +*/ + evsel->cpus =perf_cpu_map__get (evsel->pmu_cpus); + } + } +/* +* Avoid "any CPU"(-1) for uncore and PMUs that require a CPU, even if +* requested. +*/ +if (evsel->requires_cpu &&perf_cpu_map__has_any_cpu (evsel->cpus)) {perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__intersect (evlist->user_requested_cpus, evsel->pmu_cpus); + evsel->cpus =perf_cpu_map__get (evsel->pmu_cpus); + } -/* -* Empty cpu lists would eventually get opened as "any" so remove -* genuinely empty ones before they're opened in the wrong place. -*/ -if (perf_cpu_map__is_empty (evsel->cpus)) { -struct perf_evsel *next =perf_evlist__next (evlist, evsel); - -perf_evlist__remove (evlist, evsel); -/* Keep idx contiguous */ -if (next) -list_for_each_entry_from (next, &evlist->entries, node) - next->idx--; +/* +* Globally requested CPUs replace user requested unless the evsel is +* set to be system wide. +*/ +if (evlist->has_user_cpus && !evsel->system_wide) { +assert (!perf_cpu_map__has_any_cpu (evlist->user_requested_cpus)); +if (!perf_cpu_map__equal (evsel->cpus, evlist->user_requested_cpus)) { +perf_cpu_map__put (evsel->cpus); + evsel->cpus =perf_cpu_map__get (evlist->user_requested_cpus); } - }else if (!evsel->pmu_cpus || evlist->has_user_cpus || - (!evsel->requires_cpu &&perf_cpu_map__has_any_cpu (evlist->user_requested_cpus))) { -/* -* The PMU didn't specify a default cpu map, this isn't a core -* event and the user requested CPUs or the evlist user -* requested CPUs have the "any CPU" (aka dummy) CPU value. In -* which case use the user requested CPUs rather than the PMU -* ones. -*/ + } + +/* Ensure cpus only references valid PMU CPUs. */ +if (!perf_cpu_map__has_any_cpu (evsel->cpus) && + !perf_cpu_map__is_subset (evsel->pmu_cpus, evsel->cpus)) { +struct perf_cpu_map *tmp =perf_cpu_map__intersect (evsel->pmu_cpus, evsel->cpus); +perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__get (evlist->user_requested_cpus); - }else if (evsel->cpus != evsel->pmu_cpus) { -/* -* No user requested cpu map but the PMU cpu map doesn't match -* the evsel's. Reset it back to the PMU cpu map. -*/ + evsel->cpus = tmp; + } + +/* +* Was event requested on all the PMU's CPUs but the user requested is +* any CPU (-1)? If so switch to using any CPU (-1) to reduce the number +* of events. +*/ +if (!evsel->system_wide && + !evsel->requires_cpu && +perf_cpu_map__equal (evsel->cpus, evsel->pmu_cpus) && +perf_cpu_map__has_any_cpu (evlist->user_requested_cpus)) {perf_cpu_map__put (evsel->cpus); - evsel->cpus =perf_cpu_map__get (evsel->pmu_cpus); + evsel->cpus =perf_cpu_map__get (evlist->user_requested_cpus); + } + +/* Sanity check assert before the evsel is potentially removed. */ +assert (!evsel->requires_cpu || !perf_cpu_map__has_any_cpu (evsel->cpus)); + +/* +* Empty cpu lists would eventually get opened as "any" so remove +* genuinely empty ones before they're opened in the wrong place. +*/ +if (perf_cpu_map__is_empty (evsel->cpus)) { +struct perf_evsel *next =perf_evlist__next (evlist, evsel); + +perf_evlist__remove (evlist, evsel); +/* Keep idx contiguous */ +if (next) +list_for_each_entry_from (next, &evlist->entries, node) + next->idx--; + +return ; }if (evsel->system_wide) {@@ -98,6 +137,10 @@ static void perf_evlist__propagate_maps(struct perf_evlist *evlist) evlist->needs_map_propagation = true; +/* Clear the all_cpus set which will be merged into during propagation. */ +perf_cpu_map__put (evlist->all_cpus); + evlist->all_cpus =NULL ; +list_for_each_entry_safe (evsel, n, &evlist->entries, node)__perf_evlist__propagate_maps (evlist, evsel); }tools/perf/util/parse-events.c +4
-6@@ -310,20 +310,18 @@ __add_event(struct list_head *list, int *idx,if (pmu) { is_pmu_core = pmu->is_core; pmu_cpus =perf_cpu_map__get (pmu->cpus); +if (perf_cpu_map__is_empty (pmu_cpus)) + pmu_cpus =cpu_map__online (); }else { is_pmu_core = (attr->type ==PERF_TYPE_HARDWARE || attr->type ==PERF_TYPE_HW_CACHE ); pmu_cpus = is_pmu_core ?cpu_map__online () :NULL ; } -if (has_user_cpus) { +if (has_user_cpus) cpus =perf_cpu_map__get (user_cpus); -/* Existing behavior that pmu_cpus matches the given user ones. */ -perf_cpu_map__put (pmu_cpus); - pmu_cpus =perf_cpu_map__get (user_cpus); - }else { +else cpus =perf_cpu_map__get (pmu_cpus); - }if (init_attr)event_attr_init (attr);tools/perf/util/stat.c +2
-5@@ -769,8 +769,6 @@ int create_perf_stat_counter(struct evsel *evsel, attr->enable_on_exec =1 ; } -if (target__has_cpu (target) && !target__has_per_thread (target)) -return evsel__open_per_cpu (evsel,evsel__cpus (evsel), cpu_map_idx); - -return evsel__open_per_thread (evsel, evsel->core.threads); +return evsel__open_per_cpu_and_thread (evsel,evsel__cpus (evsel), cpu_map_idx, + evsel->core.threads); } --2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 13/15 perf topdown: Use attribute to see an event is a topdown metic or slots
In reply to Ian RogersThe string comparisons were overly broad and could fire for the incorrect PMU and events. Switch to using the config in the attribute then add a perf test to confirm the attribute config values match those of parsed events of that name and don't match others. This exposed matches for slots events that shouldn't have matched as the slots fixed counter event, such as topdown.slots_p.
---
v2: In test rename topdown_pmu to p_core_pmu for clarity.
--- tools/perf/arch/x86/include/arch-tests.h | 4 ++ tools/perf/arch/x86/tests/Build | 1 + tools/perf/arch/x86/tests/arch-tests.c | 1 + tools/perf/arch/x86/tests/topdown.c | 76 ++++++++++++++++++++++++ tools/perf/arch/x86/util/evsel.c | 46 ++++---------- tools/perf/arch/x86/util/topdown.c | 31 ++++------ tools/perf/arch/x86/util/topdown.h | 4 ++ 7 files changed, 108 insertions(+), 55 deletions(-) create mode 100644 tools/perf/arch/x86/tests/topdown.c
tools/perf/arch/x86/include/arch-tests.h +4 -0
@@ -2,6 +2,8 @@#ifndef ARCH_TESTS_H #define ARCH_TESTS_H +#include "tests/tests.h" +struct test_suite ;/* Tests */
@@ -17,6 +19,8 @@ int test__amd_ibs_via_core_pmu(struct test_suite *test, int subtest);int test__amd_ibs_period (struct test_suite *test,int subtest);int test__hybrid (struct test_suite *test,int subtest); +DECLARE_SUITE (x86_topdown); +extern struct test_suite *arch_tests[];#endif
tools/perf/arch/x86/tests/Build +1 -0
@@ -11,6 +11,7 @@ endif perf-test-$(CONFIG_X86_64) += bp-modify.o perf-test-y += amd-ibs-via-core-pmu.o perf-test-y += amd-ibs-period.o +perf-test-y += topdown.o ifdef SHELLCHECK SHELL_TESTS := gen-insn-x86-dat.sh
tools/perf/arch/x86/tests/arch-tests.c +1 -0
@@ -53,5 +53,6 @@ struct test_suite *arch_tests[] = { &suite__amd_ibs_via_core_pmu, &suite__amd_ibs_period, &suite__hybrid, + &suite__x86_topdown, NULL, };
tools/perf/arch/x86/tests/topdown.c new file +76 -0
76 lines not on this page · raw message
tools/perf/arch/x86/util/evsel.c +12 -34
59 lines not on this page · raw message
tools/perf/arch/x86/util/topdown.c +10 -21
@@ -1,6 +1,4 @@// SPDX-License-Identifier: GPL-2.0 -#include "api/fs/fs.h" -#include "util/evsel.h" #include "util/evlist.h" #include "util/pmu.h" #include "util/pmus.h"
@@ -8,6 +6,9 @@#include "topdown.h" #include "evsel.h" +// cmask=0, inv=0, pc=0, edge=0, umask=4, event=0 +#define TOPDOWN_SLOTS 0x0400 +/* Check whether there is a PMU which supports the perf metrics. */ bool topdown_sys_has_perf_metrics (void ) {
@@ -32,31 +33,19 @@ bool topdown_sys_has_perf_metrics(void)return has_perf_metrics; } -#define TOPDOWN_SLOTS 0x0400bool arch_is_topdown_slots (const struct evsel *evsel) { -if (evsel->core.attr.config ==TOPDOWN_SLOTS ) -return true; - -return false; +return evsel->core.attr.type ==PERF_TYPE_RAW && + evsel->core.attr.config ==TOPDOWN_SLOTS && + evsel->core.attr.config1 ==0 ; }bool arch_is_topdown_metrics (const struct evsel *evsel) { -int config = evsel->core.attr.config; -const char *name_from_config; -struct perf_pmu *pmu; - -/* All topdown events have an event code of 0. */ -if ((config &0xFF ) !=0 ) -return false; - - pmu =evsel__find_pmu (evsel); -if (!pmu || !pmu->is_core) -return false; - - name_from_config =perf_pmu__name_from_config (pmu, config); -return name_from_config &&strcasestr (name_from_config,"topdown" ); +// cmask=0, inv=0, pc=0, edge=0, umask=0x80-0x87, event=0 +return evsel->core.attr.type ==PERF_TYPE_RAW && + (evsel->core.attr.config &0xFFFFF8FF ) ==0x8000 && + evsel->core.attr.config1 ==0 ; }/*
tools/perf/arch/x86/util/topdown.h +4 -0
@@ -2,6 +2,10 @@#ifndef _TOPDOWN_H#define _TOPDOWN_H 1 +#include <stdbool.h> + +struct evsel ; +bool topdown_sys_has_perf_metrics (void );bool arch_is_topdown_slots (const struct evsel *evsel);bool arch_is_topdown_metrics (const struct evsel *evsel);
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 14/15 perf parse-events: Fix missing slots for Intel topdown metric events
In reply to Ian RogersTopdown metric events require grouping with a slots event. In perf metrics this is currently achieved by metrics adding an unnecessary "0 * tma_info_thread_slots". New TMA metrics trigger optimizations of the metric expression that removes the event and breaks the metric due to the missing but required event. Add a pass immediately before sorting and fixing parsed events, that insert a slots event if one is missing. Update test expectations to match this.
--- tools/perf/arch/x86/util/evlist.c | 24 ++++++++++++++++++++++++ tools/perf/arch/x86/util/topdown.c | 28 ++++++++++++++++++++++++++++ tools/perf/arch/x86/util/topdown.h | 2 ++ tools/perf/tests/parse-events.c | 24 ++++++++++++------------ tools/perf/util/evlist.h | 1 + tools/perf/util/parse-events.c | 10 ++++++++++ 6 files changed, 77 insertions(+), 12 deletions(-)
tools/perf/arch/x86/util/evlist.c +24 -0
@@ -81,3 +81,27 @@ int arch_evlist__cmp(const struct evsel *lhs, const struct evsel *rhs)/* Default ordering by insertion index. */ return lhs->core.idx - rhs->core.idx; } + +int arch_evlist__add_required_events (struct list_head *list) +{ +struct evsel *pos, *metric_event =NULL ; +int idx =0 ; + +if (!topdown_sys_has_perf_metrics ()) +return 0 ; + +list_for_each_entry (pos, list, core.node) { +if (arch_is_topdown_slots (pos)) { +/* Slots event already present, nothing to do. */ +return 0 ; + } +if (metric_event ==NULL &&arch_is_topdown_metrics (pos)) + metric_event = pos; + idx++; + } +if (metric_event ==NULL ) { +/* No topdown metric events, nothing to do. */ +return 0 ; + } +return topdown_insert_slots_event (list, idx +1 , metric_event); +}
tools/perf/arch/x86/util/topdown.c +28 -0
@@ -77,3 +77,31 @@ bool arch_topdown_sample_read(struct evsel *leader)return false; } + +/* +* Make a copy of the topdown metric event metric_event with the given index but +* change its configuration to be a topdown slots event. Copying from +* metric_event ensures modifiers are the same. +*/ +int topdown_insert_slots_event (struct list_head *list,int idx,struct evsel *metric_event) +{ +struct evsel *evsel =evsel__new_idx (&metric_event->core.attr, idx); + +if (!evsel) +return -ENOMEM ; + + evsel->core.attr.config =TOPDOWN_SLOTS ; + evsel->core.cpus =perf_cpu_map__get (metric_event->core.cpus); + evsel->core.pmu_cpus =perf_cpu_map__get (metric_event->core.pmu_cpus); + evsel->core.is_pmu_core = true; + evsel->pmu = metric_event->pmu; + evsel->name =strdup ("slots" ); + evsel->precise_max = metric_event->precise_max; + evsel->sample_read = metric_event->sample_read; + evsel->weak_group = metric_event->weak_group; + evsel->bpf_counter = metric_event->bpf_counter; + evsel->retire_lat = metric_event->retire_lat; +evsel__set_leader (evsel,evsel__leader (metric_event)); +list_add_tail (&evsel->core.node, list); +return 0 ; +}
tools/perf/arch/x86/util/topdown.h +2 -0
@@ -5,9 +5,11 @@#include <stdbool.h> struct evsel ; +struct list_head ;bool topdown_sys_has_perf_metrics (void );bool arch_is_topdown_slots (const struct evsel *evsel);bool arch_is_topdown_metrics (const struct evsel *evsel); +int topdown_insert_slots_event (struct list_head *list,int idx,struct evsel *metric_event);#endif
tools/perf/tests/parse-events.c +12 -12
@@ -719,20 +719,20 @@ static int test__checkevent_pmu_partial_time_callgraph(struct evlist *evlist)static int test__checkevent_pmu_events (struct evlist *evlist) { -struct evsel *evsel =evlist__first (evlist); +struct evsel *evsel; -TEST_ASSERT_VAL ("wrong number of entries" ,1 == evlist->core.nr_entries); -TEST_ASSERT_VAL ("wrong type" ,PERF_TYPE_RAW == evsel->core.attr.type || -strcmp (evsel->pmu->name,"cpu" )); -TEST_ASSERT_VAL ("wrong exclude_user" , - !evsel->core.attr.exclude_user); -TEST_ASSERT_VAL ("wrong exclude_kernel" , - evsel->core.attr.exclude_kernel); -TEST_ASSERT_VAL ("wrong exclude_hv" , evsel->core.attr.exclude_hv); -TEST_ASSERT_VAL ("wrong precise_ip" , !evsel->core.attr.precise_ip); -TEST_ASSERT_VAL ("wrong pinned" , !evsel->core.attr.pinned); -TEST_ASSERT_VAL ("wrong exclusive" , !evsel->core.attr.exclusive); +TEST_ASSERT_VAL ("wrong number of entries" ,1 <= evlist->core.nr_entries); +evlist__for_each_entry (evlist, evsel) { +TEST_ASSERT_VAL ("wrong type" ,PERF_TYPE_RAW == evsel->core.attr.type || +strcmp (evsel->pmu->name,"cpu" )); +TEST_ASSERT_VAL ("wrong exclude_user" , !evsel->core.attr.exclude_user); +TEST_ASSERT_VAL ("wrong exclude_kernel" , evsel->core.attr.exclude_kernel); +TEST_ASSERT_VAL ("wrong exclude_hv" , evsel->core.attr.exclude_hv); +TEST_ASSERT_VAL ("wrong precise_ip" , !evsel->core.attr.precise_ip); +TEST_ASSERT_VAL ("wrong pinned" , !evsel->core.attr.pinned); +TEST_ASSERT_VAL ("wrong exclusive" , !evsel->core.attr.exclusive); + }return TEST_OK ; }
tools/perf/util/evlist.h +1 -0
@@ -111,6 +111,7 @@ void evlist__add(struct evlist *evlist, struct evsel *entry);void evlist__remove (struct evlist *evlist,struct evsel *evsel);int arch_evlist__cmp (const struct evsel *lhs,const struct evsel *rhs); +int arch_evlist__add_required_events (struct list_head *list);int evlist__add_dummy (struct evlist *evlist);struct evsel *evlist__add_aux_dummy (struct evlist *evlist,bool system_wide);
tools/perf/util/parse-events.c +10 -0
@@ -2190,6 +2190,11 @@ static int evlist__cmp(void *_fg_idx, const struct list_head *l, const struct lireturn arch_evlist__cmp (lhs, rhs); } +int __weak arch_evlist__add_required_events (struct list_head *list__always_unused ) +{ +return 0 ; +} +static int parse_events__sort_events_and_fix_groups (struct list_head *list) {int idx =0 , force_grouped_idx =-1 ;
@@ -2201,6 +2206,11 @@ static int parse_events__sort_events_and_fix_groups(struct list_head *list)struct evsel *force_grouped_leader =NULL ;bool last_event_was_forced_leader = false; +/* On x86 topdown metrics events require a slots event. */ + ret =arch_evlist__add_required_events (list); +if (ret) +return ret; +/* * Compute index to insert ungrouped events at. Place them where the * first ungrouped event appears.
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Ian Rogers
reviewerPATCH v3 15/15 perf metricgroups: Add NO_THRESHOLD_AND_NMI constraint
In reply to Ian RogersThresholds can increase the number of counters a metric needs. The NMI watchdog can take away a counter (hopefully the buddy watchdog will become the default and this will no longer be true). Add a new constraint for the case that a metric and its thresholds would fit in counters but only if the NMI watchdog isn't enabled. Either the threshold or the NMI watchdog should be disabled to make the metric fit. Wire this up into the metric__group_events logic.
--- tools/perf/pmu-events/jevents.py | 1 + tools/perf/pmu-events/pmu-events.h | 14 ++++++++++---- tools/perf/util/metricgroup.c | 16 ++++++++++++---- 3 files changed, 23 insertions(+), 8 deletions(-)
tools/perf/pmu-events/jevents.py +1 -0
@@ -235,6 +235,7 @@ class JsonEvent: 'NO_GROUP_EVENTS_NMI': '2', 'NO_NMI_WATCHDOG': '2', 'NO_GROUP_EVENTS_SMT': '3', + 'NO_THRESHOLD_AND_NMI': '4', } return metric_constraint_to_enum[metric_constraint]
tools/perf/pmu-events/pmu-events.h +10 -4
@@ -25,15 +25,21 @@ enum metric_event_groups {*/ MetricNoGroupEvents =1 ,/** -* @MetricNoGroupEventsNmi: Don't group events for the metric if the NMI -* watchdog is enabled. +* @MetricNoGroupEventsNmi: +* Don't group events for the metric if the NMI watchdog is enabled. */ MetricNoGroupEventsNmi =2 ,/** -* @MetricNoGroupEventsSmt: Don't group events for the metric if SMT is -* enabled. +* @MetricNoGroupEventsSmt: +* Don't group events for the metric if SMT is enabled. */ MetricNoGroupEventsSmt =3 , +/** +* @MetricNoGroupEventsThresholdAndNmi: +* Don't group events for the metric thresholds and if the NMI watchdog +* is enabled. +*/ + MetricNoGroupEventsThresholdAndNmi = 4, };/* * Describe each PMU event. Each CPU has a table of PMU events.
tools/perf/util/metricgroup.c +12 -4
@@ -179,7 +179,7 @@ static void metric__watchdog_constraint_hint(const char *name, bool foot) " echo 1 > /proc/sys/kernel/nmi_watchdog\n"); } -static bool metric__group_events (const struct pmu_metric *pm) +static bool metric__group_events (const struct pmu_metric *pm,bool metric_no_threshold) {switch (pm->event_grouping) {case MetricNoGroupEvents:
@@ -191,6 +191,13 @@ static bool metric__group_events(const struct pmu_metric *pm)return false;case MetricNoGroupEventsSmt:return !smt_on (); +case MetricNoGroupEventsThresholdAndNmi: +if (metric_no_threshold) +return true; +if (!sysctl__nmi_watchdog_enabled ()) +return true; +metric__watchdog_constraint_hint (pm->metric_name,/*foot=*/ false); +return false;case MetricGroupEvents:default :return true;
@@ -212,6 +219,7 @@ static void metric__free(struct metric *m)static struct metric *metric__new (const struct pmu_metric *pm,const char *modifier,bool metric_no_group, +bool metric_no_threshold,int runtime,const char *user_requested_cpu_list,bool system_wide)
@@ -246,7 +254,7 @@ static struct metric *metric__new(const struct pmu_metric *pm, } m->pctx->sctx.runtime = runtime; m->pctx->sctx.system_wide = system_wide; - m->group_events = !metric_no_group &&metric__group_events (pm); + m->group_events = !metric_no_group &&metric__group_events (pm, metric_no_threshold); m->metric_refs =NULL ; m->evlist =NULL ;
@@ -831,8 +839,8 @@ static int __add_metric(struct list_head *metric_list,* This metric is the root of a tree and may reference other * metrics that are added recursively. */ - root_metric =metric__new (pm, modifier, metric_no_group, runtime, - user_requested_cpu_list, system_wide); + root_metric =metric__new (pm, modifier, metric_no_group, metric_no_threshold, + runtime, user_requested_cpu_list, system_wide);if (!root_metric)return -ENOMEM ;
Signature · 1 line
2.50.0.727.gbf7dc18ff4-goog
Quoted 9 lines · Ian Rogers
On hybrid systems some PMUs apply to all core types, particularly for metrics the msr PMU and the tsc event. The metrics often only want the values of the counter for their specific core type. These patches allow the cpu term in an event to give a PMU name to take the cpumask from. For example:
$ perf stat -e msr/tsc,cpu=cpu_atom/ ...[...]
Applied to perf-tools-next, thanks!
Best regards,
Namhyung