mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 10:34:09 +08:00
2b62b3a611
Add a new "metric-id" term to events so that metric parsing can set an ID that can be reliably looked up. Metric parsing currently will turn a metric like "instructions/cycles" into a parse events string of "{instructions,cycles}:W". However, parse-events may change "instructions" into "instructions:u" if perf_event_paranoid=2. When this happens expr__resolve_id currently fails as stat-shadow adds the ID "instructions:u" to match with the counter value and the metric tries to look up the ID just "instructions". A later patch will use the new term. An example of the current problem: $ echo -1 > /proc/sys/kernel/perf_event_paranoid $ perf stat -M IPC /bin/true Performance counter stats for '/bin/true': 1,217,161 inst_retired.any # 0.97 IPC 1,250,389 cpu_clk_unhalted.thread 0.002064773 seconds time elapsed 0.002378000 seconds user 0.000000000 seconds sys $ echo 2 > /proc/sys/kernel/perf_event_paranoid $ perf stat -M IPC /bin/true Performance counter stats for '/bin/true': 150,298 inst_retired.any:u # nan IPC 187,095 cpu_clk_unhalted.thread:u 0.002042731 seconds time elapsed 0.000000000 seconds user 0.002377000 seconds sys Note: nan IPC is printed as an effect of "perf metric: Use NAN for missing event IDs." but earlier versions of perf just fail with a parse error and display no value. Signed-off-by: Ian Rogers <irogers@google.com> Acked-by: Andi Kleen <ak@linux.intel.com> Cc: Adrian Hunter <adrian.hunter@intel.com> Cc: Alexander Antonov <alexander.antonov@linux.intel.com> Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com> Cc: Andrew Kilroy <andrew.kilroy@arm.com> Cc: Andrew Morton <akpm@linux-foundation.org> Cc: Changbin Du <changbin.du@intel.com> Cc: Denys Zagorui <dzagorui@cisco.com> Cc: Fabian Hemmer <copy@copy.sh> Cc: Felix Fietkau <nbd@nbd.name> Cc: Heiko Carstens <hca@linux.ibm.com> Cc: Ingo Molnar <mingo@redhat.com> Cc: Jacob Keller <jacob.e.keller@intel.com> Cc: Jiapeng Chong <jiapeng.chong@linux.alibaba.com> Cc: Jin Yao <yao.jin@linux.intel.com> Cc: Jiri Olsa <jolsa@redhat.com> Cc: Joakim Zhang <qiangqing.zhang@nxp.com> Cc: John Garry <john.garry@huawei.com> Cc: Kajol Jain <kjain@linux.ibm.com> Cc: Kan Liang <kan.liang@linux.intel.com> Cc: Kees Kook <keescook@chromium.org> Cc: Mark Rutland <mark.rutland@arm.com> Cc: Namhyung Kim <namhyung@kernel.org> Cc: Nicholas Fraser <nfraser@codeweavers.com> Cc: Nick Desaulniers <ndesaulniers@google.com> Cc: Paul Clarke <pc@us.ibm.com> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Riccardo Mancini <rickyman7@gmail.com> Cc: Sami Tolvanen <samitolvanen@google.com> Cc: ShihCheng Tu <mrtoastcheng@gmail.com> Cc: Song Liu <songliubraving@fb.com> Cc: Stephane Eranian <eranian@google.com> Cc: Sumanth Korikkar <sumanthk@linux.ibm.com> Cc: Thomas Richter <tmricht@linux.ibm.com> Cc: Wan Jiabing <wanjiabing@vivo.com> Cc: Zhen Lei <thunder.leizhen@huawei.com> Link: https://lore.kernel.org/r/20211015172132.1162559-15-irogers@google.com Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
292 lines
5.9 KiB
C
292 lines
5.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Support for libpfm4 event encoding.
|
|
*
|
|
* Copyright 2020 Google LLC.
|
|
*/
|
|
#include "util/cpumap.h"
|
|
#include "util/debug.h"
|
|
#include "util/event.h"
|
|
#include "util/evlist.h"
|
|
#include "util/evsel.h"
|
|
#include "util/parse-events.h"
|
|
#include "util/pmu.h"
|
|
#include "util/pfm.h"
|
|
|
|
#include <string.h>
|
|
#include <linux/kernel.h>
|
|
#include <perfmon/pfmlib_perf_event.h>
|
|
|
|
static void libpfm_initialize(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = pfm_initialize();
|
|
if (ret != PFM_SUCCESS) {
|
|
ui__warning("libpfm failed to initialize: %s\n",
|
|
pfm_strerror(ret));
|
|
}
|
|
}
|
|
|
|
int parse_libpfm_events_option(const struct option *opt, const char *str,
|
|
int unset __maybe_unused)
|
|
{
|
|
struct evlist *evlist = *(struct evlist **)opt->value;
|
|
struct perf_event_attr attr;
|
|
struct perf_pmu *pmu;
|
|
struct evsel *evsel, *grp_leader = NULL;
|
|
char *p, *q, *p_orig;
|
|
const char *sep;
|
|
int grp_evt = -1;
|
|
int ret;
|
|
|
|
libpfm_initialize();
|
|
|
|
p_orig = p = strdup(str);
|
|
if (!p)
|
|
return -1;
|
|
/*
|
|
* force loading of the PMU list
|
|
*/
|
|
perf_pmu__scan(NULL);
|
|
|
|
for (q = p; strsep(&p, ",{}"); q = p) {
|
|
sep = p ? str + (p - p_orig - 1) : "";
|
|
if (*sep == '{') {
|
|
if (grp_evt > -1) {
|
|
ui__error(
|
|
"nested event groups not supported\n");
|
|
goto error;
|
|
}
|
|
grp_evt++;
|
|
}
|
|
|
|
/* no event */
|
|
if (*q == '\0') {
|
|
if (*sep == '}') {
|
|
if (grp_evt < 0) {
|
|
ui__error("cannot close a non-existing event group\n");
|
|
goto error;
|
|
}
|
|
grp_evt--;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
memset(&attr, 0, sizeof(attr));
|
|
event_attr_init(&attr);
|
|
|
|
ret = pfm_get_perf_event_encoding(q, PFM_PLM0|PFM_PLM3,
|
|
&attr, NULL, NULL);
|
|
|
|
if (ret != PFM_SUCCESS) {
|
|
ui__error("failed to parse event %s : %s\n", str,
|
|
pfm_strerror(ret));
|
|
goto error;
|
|
}
|
|
|
|
pmu = perf_pmu__find_by_type((unsigned int)attr.type);
|
|
evsel = parse_events__add_event(evlist->core.nr_entries,
|
|
&attr, q, /*metric_id=*/NULL,
|
|
pmu);
|
|
if (evsel == NULL)
|
|
goto error;
|
|
|
|
evsel->is_libpfm_event = true;
|
|
|
|
evlist__add(evlist, evsel);
|
|
|
|
if (grp_evt == 0)
|
|
grp_leader = evsel;
|
|
|
|
if (grp_evt > -1) {
|
|
evsel__set_leader(evsel, grp_leader);
|
|
grp_leader->core.nr_members++;
|
|
grp_evt++;
|
|
}
|
|
|
|
if (*sep == '}') {
|
|
if (grp_evt < 0) {
|
|
ui__error(
|
|
"cannot close a non-existing event group\n");
|
|
goto error;
|
|
}
|
|
evlist->core.nr_groups++;
|
|
grp_leader = NULL;
|
|
grp_evt = -1;
|
|
}
|
|
}
|
|
free(p_orig);
|
|
return 0;
|
|
error:
|
|
free(p_orig);
|
|
return -1;
|
|
}
|
|
|
|
static const char *srcs[PFM_ATTR_CTRL_MAX] = {
|
|
[PFM_ATTR_CTRL_UNKNOWN] = "???",
|
|
[PFM_ATTR_CTRL_PMU] = "PMU",
|
|
[PFM_ATTR_CTRL_PERF_EVENT] = "perf_event",
|
|
};
|
|
|
|
static void
|
|
print_attr_flags(pfm_event_attr_info_t *info)
|
|
{
|
|
int n = 0;
|
|
|
|
if (info->is_dfl) {
|
|
printf("[default] ");
|
|
n++;
|
|
}
|
|
|
|
if (info->is_precise) {
|
|
printf("[precise] ");
|
|
n++;
|
|
}
|
|
|
|
if (!n)
|
|
printf("- ");
|
|
}
|
|
|
|
static void
|
|
print_libpfm_events_detailed(pfm_event_info_t *info, bool long_desc)
|
|
{
|
|
pfm_event_attr_info_t ainfo;
|
|
const char *src;
|
|
int j, ret;
|
|
|
|
ainfo.size = sizeof(ainfo);
|
|
|
|
printf(" %s\n", info->name);
|
|
printf(" [%s]\n", info->desc);
|
|
if (long_desc) {
|
|
if (info->equiv)
|
|
printf(" Equiv: %s\n", info->equiv);
|
|
|
|
printf(" Code : 0x%"PRIx64"\n", info->code);
|
|
}
|
|
pfm_for_each_event_attr(j, info) {
|
|
ret = pfm_get_event_attr_info(info->idx, j,
|
|
PFM_OS_PERF_EVENT_EXT, &ainfo);
|
|
if (ret != PFM_SUCCESS)
|
|
continue;
|
|
|
|
if (ainfo.type == PFM_ATTR_UMASK) {
|
|
printf(" %s:%s\n", info->name, ainfo.name);
|
|
printf(" [%s]\n", ainfo.desc);
|
|
}
|
|
|
|
if (!long_desc)
|
|
continue;
|
|
|
|
if (ainfo.ctrl >= PFM_ATTR_CTRL_MAX)
|
|
ainfo.ctrl = PFM_ATTR_CTRL_UNKNOWN;
|
|
|
|
src = srcs[ainfo.ctrl];
|
|
switch (ainfo.type) {
|
|
case PFM_ATTR_UMASK:
|
|
printf(" Umask : 0x%02"PRIx64" : %s: ",
|
|
ainfo.code, src);
|
|
print_attr_flags(&ainfo);
|
|
putchar('\n');
|
|
break;
|
|
case PFM_ATTR_MOD_BOOL:
|
|
printf(" Modif : %s: [%s] : %s (boolean)\n", src,
|
|
ainfo.name, ainfo.desc);
|
|
break;
|
|
case PFM_ATTR_MOD_INTEGER:
|
|
printf(" Modif : %s: [%s] : %s (integer)\n", src,
|
|
ainfo.name, ainfo.desc);
|
|
break;
|
|
case PFM_ATTR_NONE:
|
|
case PFM_ATTR_RAW_UMASK:
|
|
case PFM_ATTR_MAX:
|
|
default:
|
|
printf(" Attr : %s: [%s] : %s\n", src,
|
|
ainfo.name, ainfo.desc);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* list all pmu::event:umask, pmu::event
|
|
* printed events may not be all valid combinations of umask for an event
|
|
*/
|
|
static void
|
|
print_libpfm_events_raw(pfm_pmu_info_t *pinfo, pfm_event_info_t *info)
|
|
{
|
|
pfm_event_attr_info_t ainfo;
|
|
int j, ret;
|
|
bool has_umask = false;
|
|
|
|
ainfo.size = sizeof(ainfo);
|
|
|
|
pfm_for_each_event_attr(j, info) {
|
|
ret = pfm_get_event_attr_info(info->idx, j,
|
|
PFM_OS_PERF_EVENT_EXT, &ainfo);
|
|
if (ret != PFM_SUCCESS)
|
|
continue;
|
|
|
|
if (ainfo.type != PFM_ATTR_UMASK)
|
|
continue;
|
|
|
|
printf("%s::%s:%s\n", pinfo->name, info->name, ainfo.name);
|
|
has_umask = true;
|
|
}
|
|
if (!has_umask)
|
|
printf("%s::%s\n", pinfo->name, info->name);
|
|
}
|
|
|
|
void print_libpfm_events(bool name_only, bool long_desc)
|
|
{
|
|
pfm_event_info_t info;
|
|
pfm_pmu_info_t pinfo;
|
|
int i, p, ret;
|
|
|
|
libpfm_initialize();
|
|
|
|
/* initialize to zero to indicate ABI version */
|
|
info.size = sizeof(info);
|
|
pinfo.size = sizeof(pinfo);
|
|
|
|
if (!name_only)
|
|
puts("\nList of pre-defined events (to be used in --pfm-events):\n");
|
|
|
|
pfm_for_all_pmus(p) {
|
|
bool printed_pmu = false;
|
|
|
|
ret = pfm_get_pmu_info(p, &pinfo);
|
|
if (ret != PFM_SUCCESS)
|
|
continue;
|
|
|
|
/* only print events that are supported by host HW */
|
|
if (!pinfo.is_present)
|
|
continue;
|
|
|
|
/* handled by perf directly */
|
|
if (pinfo.pmu == PFM_PMU_PERF_EVENT)
|
|
continue;
|
|
|
|
for (i = pinfo.first_event; i != -1;
|
|
i = pfm_get_event_next(i)) {
|
|
|
|
ret = pfm_get_event_info(i, PFM_OS_PERF_EVENT_EXT,
|
|
&info);
|
|
if (ret != PFM_SUCCESS)
|
|
continue;
|
|
|
|
if (!name_only && !printed_pmu) {
|
|
printf("%s:\n", pinfo.name);
|
|
printed_pmu = true;
|
|
}
|
|
|
|
if (!name_only)
|
|
print_libpfm_events_detailed(&info, long_desc);
|
|
else
|
|
print_libpfm_events_raw(&pinfo, &info);
|
|
}
|
|
if (!name_only && printed_pmu)
|
|
putchar('\n');
|
|
}
|
|
}
|