From: Ian Rogers <irogers@google.com>
To: Peter Zijlstra <peterz@infradead.org>,
Ingo Molnar <mingo@redhat.com>,
Arnaldo Carvalho de Melo <acme@kernel.org>,
Namhyung Kim <namhyung@kernel.org>, Jiri Olsa <jolsa@kernel.org>,
Ian Rogers <irogers@google.com>,
Adrian Hunter <adrian.hunter@intel.com>,
James Clark <james.clark@linaro.org>
Cc: linux-perf-users@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: [PATCH v3 25/30] perf pmus: Add perf_pmus__read_from_env()
Date: Fri, 20 Nov 2026 14:13:26 -0800 [thread overview]
Message-ID: <20261120221332.2245191-26-irogers@google.com> (raw)
In-Reply-To: <20261120221332.2245191-1-irogers@google.com>
Add perf_pmus__read_from_env() and perf_pmu__add_cap() to reconstruct
core_pmus and other_pmus lists and their capabilities in a
struct perf_pmus from HEADER_PMU_MAPPINGS, HEADER_HYBRID_TOPOLOGY,
HEADER_PMU_CAPS, and HEADER_CPU_PMU_CAPS in a perf.data header
environment, and lazily populate env->pmus in perf_env__pmus(). An
environment without any PMU header metadata, such as one used while
recording, falls back to the live host's PMUs rather than re-reading
sysfs into its own copy.
Ensure core_pmus is never left empty by creating a fallback "cpu" core
PMU when no core PMU was found in the headers. Because perf.data headers
do not record sysfs format definitions, only attach core_table to PMUs
with matching entries and teach perf_pmu__for_each_name_from_config() to
delegate to a matching live host PMU or fall back to legacy hardware and
cache event names.
Signed-off-by: Ian Rogers <irogers@google.com>
---
tools/perf/util/env.c | 19 +++
tools/perf/util/env.h | 5 +
| 23 ++++
tools/perf/util/pmu.c | 56 ++++++++-
tools/perf/util/pmu.h | 9 ++
tools/perf/util/pmus.c | 247 +++++++++++++++++++++++++++++++++++++++
tools/perf/util/pmus.h | 15 ++-
7 files changed, 372 insertions(+), 2 deletions(-)
diff --git a/tools/perf/util/env.c b/tools/perf/util/env.c
index fec6a5a8ecb6..a6f0baef3ccf 100644
--- a/tools/perf/util/env.c
+++ b/tools/perf/util/env.c
@@ -341,6 +341,25 @@ struct perf_env *host_env(void)
struct perf_pmus *perf_env__pmus(struct perf_env *env)
{
+ struct perf_env *host = host_env();
+
+ if (env == host ||
+ (env->pmus.read_pmu_types == 0 &&
+ !(env->nr_pmu_mappings || env->nr_hybrid_nodes ||
+ env->nr_cpu_pmu_caps || env->nr_pmus_with_caps))) {
+ /* No PMU metadata of its own, use the live host's PMUs. */
+ return &host->pmus;
+ }
+
+ mutex_lock(&env->lock);
+ if (!env->pmus.core_pmus.next || !env->pmus.other_pmus.next)
+ perf_pmus__init(&env->pmus);
+ mutex_unlock(&env->lock);
+
+ mutex_lock(&env->pmus.lock);
+ if (env->pmus.read_pmu_types == 0)
+ perf_pmus__read_from_env(&env->pmus, env);
+ mutex_unlock(&env->pmus.lock);
return &env->pmus;
}
diff --git a/tools/perf/util/env.h b/tools/perf/util/env.h
index e38e953060c9..ef583161583f 100644
--- a/tools/perf/util/env.h
+++ b/tools/perf/util/env.h
@@ -238,6 +238,11 @@ struct perf_env *host_env(void);
* perf_env__pmus() - Return the struct perf_pmus associated with @env.
* @env: Environment whose PMU collection to retrieve.
*
+ * For non-host environments with PMU header metadata (HEADER_PMU_MAPPINGS,
+ * HEADER_HYBRID_TOPOLOGY, HEADER_CPU_PMU_CAPS or HEADER_PMU_CAPS), lazily
+ * populates @env->pmus from the perf.data header on first access. If @env has
+ * no PMU metadata of its own, falls back to the live host's PMU collection.
+ *
* Return: Pointer to the struct perf_pmus for @env.
*/
struct perf_pmus *perf_env__pmus(struct perf_env *env);
--git a/tools/perf/util/header.c b/tools/perf/util/header.c
index c1f77babcb70..48b7a86f6f9d 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -5762,6 +5762,29 @@ int perf_event__process_feature(const struct perf_tool *tool __maybe_unused,
goto out;
}
+ switch (feat) {
+ case HEADER_ARCH:
+ case HEADER_CPUID:
+ case HEADER_NRCPUS:
+ case HEADER_PMU_MAPPINGS:
+ case HEADER_CPU_PMU_CAPS:
+ case HEADER_HYBRID_TOPOLOGY:
+ case HEADER_PMU_CAPS:
+ case HEADER_E_MACHINE:
+ mutex_lock(&header->env.pmus.lock);
+ if (session->evlist) {
+ struct evsel *evsel;
+
+ evlist__for_each_entry(session->evlist, evsel)
+ evsel->pmu = NULL;
+ }
+ perf_pmus__exit(&header->env.pmus);
+ mutex_unlock(&header->env.pmus.lock);
+ break;
+ default:
+ break;
+ }
+
if (session->tool->show_feat_hdr) {
if (!feat_ops[feat].full_only ||
session->tool->show_feat_hdr >= SHOW_FEAT_HEADER_FULL_INFO) {
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index b4541fbfc9c0..1d3cfa082347 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -2250,7 +2250,7 @@ static bool perf_pmu_alias__check_deprecated(struct perf_pmu *pmu, struct perf_p
const char *check_terms;
bool has_legacy_config;
- if (alias->legacy_deprecated_checked)
+ if (pmu->from_env || alias->legacy_deprecated_checked)
return alias->deprecated;
alias->legacy_deprecated_checked = true;
@@ -2583,6 +2583,37 @@ static int perf_pmu__new_caps(struct list_head *list, char *name, char *value)
return -ENOMEM;
}
+int perf_pmu__add_cap(struct perf_pmu *pmu, const char *name, const char *value)
+{
+ struct perf_pmu_caps *caps;
+
+ if (!pmu || !name || !value)
+ return -EINVAL;
+ if (perf_pmu__get_cap(pmu, name))
+ return 0;
+
+ caps = zalloc(sizeof(*caps));
+ if (!caps)
+ return -ENOMEM;
+
+ caps->name = strdup(name);
+ if (!caps->name) {
+ free(caps);
+ return -ENOMEM;
+ }
+ caps->value = strdup(value);
+ if (!caps->value) {
+ zfree(&caps->name);
+ free(caps);
+ return -ENOMEM;
+ }
+ list_add_tail(&caps->list, &pmu->caps);
+ pmu->nr_caps++;
+ if (!strcmp(name, "max_precise"))
+ pmu->max_precise = atoi(value);
+ return 0;
+}
+
static void perf_pmu__del_caps(struct perf_pmu *pmu)
{
struct perf_pmu_caps *caps, *tmp;
@@ -2881,6 +2912,28 @@ int perf_pmu__for_each_name_from_config(struct perf_pmu *pmu, __u32 type, u64 co
if (!pmu)
return 0;
+ /*
+ * PMUs reconstructed from perf.data headers lack sysfs format files, so
+ * format-based JSON aliases cannot be parsed directly. Delegate to the
+ * matching live host PMU when available, otherwise only resolve legacy
+ * hardware and cache encodings.
+ */
+ if (pmu->from_env && list_empty(&pmu->format) &&
+ pmu->events_table != perf_pmu__default_core_events_table()) {
+ struct perf_pmu *host_pmu =
+ perf_pmus__find(perf_env__pmus(host_env()), pmu->name);
+
+ if (host_pmu && !host_pmu->from_env &&
+ host_pmu->events_table == pmu->events_table &&
+ (pmu->events_table || !pmu->is_core)) {
+ __u32 match_type = (type == pmu->type) ? host_pmu->type : type;
+
+ return perf_pmu__for_each_name_from_config(host_pmu, match_type,
+ config, cb, data);
+ }
+ goto legacy_names;
+ }
+
pmu_aliases_parse(pmu);
pmu_add_cpu_aliases(pmu);
hashmap__for_each_entry(pmu->aliases, entry, bkt) {
@@ -2894,6 +2947,7 @@ int perf_pmu__for_each_name_from_config(struct perf_pmu *pmu, __u32 type, u64 co
if (ret)
return ret;
}
+legacy_names:
if (pmu->is_core && (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE)) {
struct legacy_name_args args = {
.type = type,
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index ab7123964423..b556ec51fdeb 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -334,6 +334,15 @@ bool pmu_uncore_identifier_match(const char *compat, const char *id);
int perf_pmu__convert_scale(const char *scale, char **end, double *sval);
struct perf_pmu_caps *perf_pmu__get_cap(struct perf_pmu *pmu, const char *name);
+/**
+ * perf_pmu__add_cap() - Add a name/value capability entry to @pmu->caps.
+ * @pmu: The PMU to add the capability to.
+ * @name: Capability name.
+ * @value: Capability value string.
+ *
+ * Return: 0 on success, negative error code on failure.
+ */
+int perf_pmu__add_cap(struct perf_pmu *pmu, const char *name, const char *value);
int perf_pmu__caps_parse(struct perf_pmu *pmu);
diff --git a/tools/perf/util/pmus.c b/tools/perf/util/pmus.c
index 1c3cb53c3d4f..c5ef22ef00dc 100644
--- a/tools/perf/util/pmus.c
+++ b/tools/perf/util/pmus.c
@@ -7,13 +7,16 @@
#include <subcmd/pager.h>
#include <sys/types.h>
#include <ctype.h>
+#include <errno.h>
#include <pthread.h>
+#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "cpumap.h"
#include "debug.h"
#include "drm_pmu.h"
+#include "dwarf-regs.h"
#include "env.h"
#include "evsel.h"
#include "pmus.h"
@@ -1004,3 +1007,247 @@ struct perf_pmu *perf_pmus__fake_pmu(void)
return &fake;
}
+
+/*
+ * Determine whether a PMU name reconstructed from perf.data headers is a
+ * core PMU, checking common core PMU prefixes, hybrid topology nodes, and
+ * the host architecture's is_pmu_core() when architectures match.
+ */
+static bool env_is_pmu_core(const char *name, struct perf_env *env)
+{
+ if (!strcmp(name, "cpu") || !strcmp(name, "cpum_cf") ||
+ !strcmp(name, "default_core") || !strcmp(name, "arc_pct") ||
+ strstarts(name, "cpu_") || strstarts(name, "armv") ||
+ (strstarts(name, "apple_") && strstr(name, "_pmu")))
+ return true;
+
+ if (env && env->hybrid_nodes) {
+ for (int i = 0; i < env->nr_hybrid_nodes; i++) {
+ const char *pmu_name = env->hybrid_nodes[i].pmu_name;
+
+ if (pmu_name && !strcmp(name, pmu_name))
+ return true;
+ }
+ return false;
+ }
+
+ if (!env || e_machine__same_arch(perf_env__e_machine(env, /*e_flags=*/NULL),
+ perf_env__e_machine(host_env(), /*e_flags=*/NULL)))
+ return is_pmu_core(name);
+
+ return false;
+}
+
+/*
+ * Look up @name in @pmus or allocate and initialize a new perf_env-backed
+ * struct perf_pmu, upgrading PERF_PMU_TYPE_FAKE if a real type is later
+ * discovered.
+ */
+static struct perf_pmu *env_pmu_find_or_add(struct perf_pmus *pmus,
+ const char *name, __u32 type,
+ struct perf_env *env,
+ const struct pmu_events_table *core_table)
+{
+ struct perf_pmu *pmu = pmu_find(pmus, name);
+
+ if (type == PERF_PMU_TYPE_FAKE) {
+ if (!strcmp(name, "software"))
+ type = PERF_TYPE_SOFTWARE;
+ else if (!strcmp(name, "tracepoint"))
+ type = PERF_TYPE_TRACEPOINT;
+ else if (!strcmp(name, "breakpoint"))
+ type = PERF_TYPE_BREAKPOINT;
+ else if (!strcmp(name, "tool"))
+ type = PERF_PMU_TYPE_TOOL;
+ }
+
+ if (pmu) {
+ if (pmu->type == PERF_PMU_TYPE_FAKE && type != PERF_PMU_TYPE_FAKE) {
+ pmu->type = type;
+ if (!pmu->is_core && type == PERF_TYPE_RAW) {
+ pmu->is_core = true;
+ list_move_tail(&pmu->list, &pmus->core_pmus);
+ }
+ pmu->is_uncore = !pmu->is_core && !pmu->auxtrace &&
+ !perf_pmu__is_software(pmu) &&
+ perf_pmu__kind(pmu) == PERF_PMU_KIND_PE;
+ if (!pmu->is_core && !pmu->is_uncore &&
+ pmu->events_table == core_table) {
+ pmu->events_table = NULL;
+ } else if (!pmu->events_table && (pmu->is_core || pmu->is_uncore) &&
+ pmu_events_table__num_events(core_table, pmu) > 0) {
+ pmu->events_table = core_table;
+ }
+ }
+ return pmu;
+ }
+
+ pmu = zalloc(sizeof(*pmu));
+ if (!pmu)
+ return NULL;
+
+ if (perf_pmu__init(pmu, type, name, /*from_env=*/true) != 0) {
+ perf_pmu__delete(pmu);
+ return NULL;
+ }
+
+ pmu->pmus = pmus;
+ pmu->sysfs_aliases_loaded = true;
+ pmu->caps_initialized = true;
+ pmu->max_precise = -1;
+ pmu->is_core = type == PERF_TYPE_RAW || env_is_pmu_core(name, env);
+ pmu->auxtrace = !strcmp(name, "intel_pt") ||
+ !strcmp(name, "intel_bts") ||
+ !strcmp(name, "cs_etm") ||
+ strstarts(name, "arm_spe") ||
+ strstarts(name, "hisi_ptt");
+ pmu->is_uncore = !pmu->is_core && !pmu->auxtrace &&
+ !perf_pmu__is_software(pmu) &&
+ (perf_pmu__kind(pmu) == PERF_PMU_KIND_PE ||
+ pmu->type == PERF_PMU_TYPE_FAKE);
+
+ if (!strcmp(name, "software") || !strcmp(name, "tool"))
+ pmu->events_table = perf_pmu__default_core_events_table();
+ else if ((pmu->is_core || pmu->is_uncore) &&
+ pmu_events_table__num_events(core_table, pmu) > 0)
+ pmu->events_table = core_table;
+
+ list_add_tail(&pmu->list, pmu->is_core ? &pmus->core_pmus : &pmus->other_pmus);
+ return pmu;
+}
+
+/* Parse "key=value" capability strings from perf_env into @pmu->caps. */
+static void env_pmu_add_caps_strings(struct perf_pmu *pmu, int nr_caps, char **caps)
+{
+ if (!pmu || nr_caps <= 0 || !caps)
+ return;
+
+ for (int i = 0; i < nr_caps; i++) {
+ const char *eq;
+
+ if (!caps[i])
+ continue;
+ eq = strchr(caps[i], '=');
+
+ if (eq) {
+ char *key = strndup(caps[i], eq - caps[i]);
+
+ if (key) {
+ perf_pmu__add_cap(pmu, key, eq + 1);
+ free(key);
+ }
+ } else {
+ perf_pmu__add_cap(pmu, caps[i], "");
+ }
+ }
+}
+
+int perf_pmus__read_from_env(struct perf_pmus *pmus, struct perf_env *env)
+{
+ const struct pmu_events_table *core_table = NULL;
+ struct perf_pmu *pmu;
+
+ if (!pmus || !env)
+ return -EINVAL;
+
+ perf_pmus__exit(pmus);
+ pmus->read_pmu_types = PERF_TOOL_PMU_TYPE_ALL_MASK;
+
+ if (env->cpuid)
+ core_table = find_core_events_table(perf_env__e_machine(env, /*e_flags=*/NULL),
+ env->cpuid);
+
+ /* 1. Populate from HEADER_PMU_MAPPINGS */
+ if (env->nr_pmu_mappings > 0 && env->pmu_mappings) {
+ char *str = env->pmu_mappings;
+
+ for (int i = 0; i < env->nr_pmu_mappings; i++) {
+ char *colon = NULL;
+ unsigned long type = strtoul(str, &colon, 0);
+
+ if (!colon || *colon != ':')
+ break;
+ str = colon + 1;
+ env_pmu_find_or_add(pmus, str, (__u32)type, env, core_table);
+ str += strlen(str) + 1;
+ }
+ }
+
+ /* 2. Populate/enrich from HEADER_HYBRID_TOPOLOGY */
+ for (int i = 0; i < env->nr_hybrid_nodes; i++) {
+ struct hybrid_node *hn = &env->hybrid_nodes[i];
+
+ if (!hn->pmu_name)
+ continue;
+ pmu = env_pmu_find_or_add(pmus, hn->pmu_name, PERF_PMU_TYPE_FAKE,
+ env, core_table);
+ if (!pmu)
+ continue;
+ if (!pmu->is_core) {
+ pmu->is_core = true;
+ pmu->is_uncore = false;
+ if (!pmu->events_table &&
+ pmu_events_table__num_events(core_table, pmu) > 0)
+ pmu->events_table = core_table;
+ list_move_tail(&pmu->list, &pmus->core_pmus);
+ }
+ if (hn->cpus && !pmu->cpus)
+ pmu->cpus = perf_cpu_map__new(hn->cpus);
+ }
+
+ /* 3. Populate/enrich from HEADER_PMU_CAPS */
+ for (int i = 0; i < env->nr_pmus_with_caps; i++) {
+ struct pmu_caps *pc = &env->pmu_caps[i];
+
+ if (!pc->pmu_name)
+ continue;
+ pmu = env_pmu_find_or_add(pmus, pc->pmu_name, PERF_PMU_TYPE_FAKE,
+ env, core_table);
+ if (pmu)
+ env_pmu_add_caps_strings(pmu, pc->nr_caps, pc->caps);
+ }
+
+ /*
+ * 4. Populate/enrich from HEADER_CPU_PMU_CAPS.
+ * HEADER_CPU_PMU_CAPS holds the capabilities of the first core PMU,
+ * named "cpu" on x86 but e.g. "armv8_pmuv3_0" or "cpum_cf" elsewhere.
+ * On hybrid systems it duplicates the first core PMU's entry in
+ * HEADER_PMU_CAPS. Attach the capabilities to "cpu" if present,
+ * otherwise to the first core PMU when it has no capabilities yet,
+ * creating a "cpu" PMU only if no core PMUs exist.
+ */
+ if (env->nr_cpu_pmu_caps > 0 && env->cpu_pmu_caps) {
+ pmu = pmu_find(pmus, "cpu");
+ if (!pmu && !list_empty(&pmus->core_pmus)) {
+ /* Match the writer's perf_pmus__find_core_pmu() order. */
+ list_sort(NULL, &pmus->core_pmus, pmus_cmp);
+ pmu = list_first_entry(&pmus->core_pmus, struct perf_pmu, list);
+ if (pmu->nr_caps > 0)
+ pmu = NULL;
+ } else if (!pmu) {
+ pmu = env_pmu_find_or_add(pmus, "cpu", PERF_TYPE_RAW,
+ env, core_table);
+ }
+ if (pmu)
+ env_pmu_add_caps_strings(pmu, env->nr_cpu_pmu_caps, env->cpu_pmu_caps);
+ }
+
+ /* Ensure core_pmus is non-empty, matching pmu_read_sysfs()'s placeholder. */
+ if (list_empty(&pmus->core_pmus))
+ env_pmu_find_or_add(pmus, "cpu", PERF_TYPE_RAW, env, core_table);
+
+ /* 5. Set default core CPUs on non-hybrid systems */
+ if (env->nr_cpus_avail > 0 && env->nr_hybrid_nodes == 0) {
+ char buf[64];
+
+ snprintf(buf, sizeof(buf), "0-%d", env->nr_cpus_avail - 1);
+ list_for_each_entry(pmu, &pmus->core_pmus, list) {
+ if (!pmu->cpus)
+ pmu->cpus = perf_cpu_map__new(buf);
+ }
+ }
+
+ list_sort(NULL, &pmus->core_pmus, pmus_cmp);
+ list_sort(NULL, &pmus->other_pmus, pmus_cmp);
+ return 0;
+}
diff --git a/tools/perf/util/pmus.h b/tools/perf/util/pmus.h
index 6e7c9f857aaf..2b784cf648f3 100644
--- a/tools/perf/util/pmus.h
+++ b/tools/perf/util/pmus.h
@@ -8,6 +8,7 @@
#include "mutex.h"
struct perf_event_attr;
+struct perf_env;
struct perf_pmu;
struct print_callbacks;
@@ -49,7 +50,10 @@ struct perf_pmus {
* encoding in perf_event_attr::config is supported.
*/
enum perf_pmus_extended_type extended_type;
- /** @lock: Protects lazy initialization of @extended_type. */
+ /**
+ * @lock: Protects lazy initialization of @extended_type and
+ * perf_pmus__read_from_env().
+ */
struct mutex lock;
};
@@ -75,6 +79,15 @@ void perf_pmus__init(struct perf_pmus *pmus);
*/
void perf_pmus__exit(struct perf_pmus *pmus);
+/**
+ * perf_pmus__read_from_env() - Populate @pmus from perf.data header metadata.
+ * @pmus: The PMU collection to populate.
+ * @env: The perf_env containing header PMU mappings, hybrid topology, and caps.
+ *
+ * Return: 0 on success, negative error code on failure.
+ */
+int perf_pmus__read_from_env(struct perf_pmus *pmus, struct perf_env *env);
+
/**
* perf_pmus__find() - Find a PMU by name in @pmus.
* @pmus: The PMU collection to search.
--
2.56.1.750.gf70dc682cf-goog
next prev parent reply other threads:[~2026-11-20 22:15 UTC|newest]
Thread overview: 33+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-20 22:13 [PATCH v3 00/30] perf: Per-env PMUs, metric event sharing, and recorded event metrics Ian Rogers
2026-11-20 22:13 ` [PATCH v3 01/30] perf pmus: Don't skip core PMUs as duplicates Ian Rogers
2026-11-20 22:13 ` [PATCH v3 02/30] perf script: Fix metrics computed from samples Ian Rogers
2026-11-20 22:13 ` [PATCH v3 03/30] perf script: Don't drop metric samples for CPUs missing from the evsel Ian Rogers
2026-11-20 22:13 ` [PATCH v3 04/30] perf metricgroup: Don't prefer tool events for displaying a metric Ian Rogers
2026-11-20 22:13 ` [PATCH v3 05/30] perf env: Make lazy perf_env initialization thread-safe Ian Rogers
2026-11-20 22:13 ` [PATCH v3 06/30] perf env: Add host_env() singleton Ian Rogers
2026-11-20 22:13 ` [PATCH v3 07/30] perf pmu: Add from_env parameter to perf_pmu__init() Ian Rogers
2026-11-20 22:13 ` [PATCH v3 08/30] perf pmus: Introduce struct perf_pmus and perf_env__pmus() Ian Rogers
2026-11-20 22:13 ` [PATCH v3 09/30] perf pmus: Pass struct perf_pmus to find helpers Ian Rogers
2026-11-20 22:13 ` [PATCH v3 10/30] perf pmus: Pass struct perf_pmus to scan helpers Ian Rogers
2026-11-20 22:13 ` [PATCH v3 11/30] perf pmu-events: Add e_machine to struct pmu_events_map Ian Rogers
2026-11-20 22:13 ` [PATCH v3 12/30] perf pmu-events: Pass e_machine to find_core_*_table() Ian Rogers
2026-11-20 22:13 ` [PATCH v3 13/30] perf header: Pass e_machine to strcmp_cpuid_str() Ian Rogers
2026-11-20 22:13 ` [PATCH v3 14/30] perf header: Support CPUID matching across all architectures Ian Rogers
2026-11-20 22:13 ` [PATCH v3 15/30] perf test: Make the CPUID matching test architecture independent Ian Rogers
2026-11-20 22:13 ` [PATCH v3 16/30] perf test: Add CPUID matching tests for other architectures Ian Rogers
2026-11-20 22:13 ` [PATCH v3 17/30] perf dwarf-regs: Add e_machine__same_arch() Ian Rogers
2026-11-20 22:13 ` [PATCH v3 18/30] perf metricgroup: Pass struct perf_pmus to metricgroup__for_each_metric() Ian Rogers
2026-11-20 22:13 ` [PATCH v3 19/30] perf metricgroup: Move matching of metrics to recorded events from perf script Ian Rogers
2026-11-20 22:13 ` [PATCH v3 20/30] perf parse-events: Decode metric-id terms when adding events Ian Rogers
2026-11-20 22:13 ` [PATCH v3 21/30] perf evsel: Generalize metric_id to a set of metric_ids Ian Rogers
2026-11-20 22:13 ` [PATCH v3 22/30] perf pmu: Add perf_pmu__for_each_name_from_config() Ian Rogers
2026-11-20 22:13 ` [PATCH v3 23/30] perf metricgroup: Share metric events by their counter encoding Ian Rogers
2026-11-20 22:13 ` [PATCH v3 24/30] perf stat: Share events between metrics and command line events Ian Rogers
2026-11-20 22:13 ` Ian Rogers [this message]
2026-11-20 22:42 ` [PATCH v3 25/30] perf pmus: Add perf_pmus__read_from_env() sashiko-bot
2026-11-20 22:13 ` [PATCH v3 26/30] perf metricgroup: Improve matching of metrics to recorded events Ian Rogers
2026-11-20 22:13 ` [PATCH v3 27/30] perf metricgroup: Add metricgroup__add_recorded_metrics() Ian Rogers
2026-11-20 22:13 ` [PATCH v3 28/30] perf stat report: Display metrics for recorded events Ian Rogers
2026-11-20 22:13 ` [PATCH v3 29/30] perf script: Display metrics for perf stat record data Ian Rogers
2026-11-20 22:13 ` [PATCH v3 30/30] perf test: Add stat record metrics test Ian Rogers
2026-11-20 22:42 ` [PATCH v3 00/30] perf: Per-env PMUs, metric event sharing, and recorded event metrics sashiko-bot
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261120221332.2245191-26-irogers@google.com \
--to=irogers@google.com \
--cc=acme@kernel.org \
--cc=adrian.hunter@intel.com \
--cc=james.clark@linaro.org \
--cc=jolsa@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-perf-users@vger.kernel.org \
--cc=mingo@redhat.com \
--cc=namhyung@kernel.org \
--cc=peterz@infradead.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.