Skip to contentSkip to conversation

Add core wide metric literal

PATCH In review Ian Rogers 2 participants 11 messages Aug 31, 2022 – Sep 9, 2022 perf events

lore
Share & tools
lore

Ian Rogers

author reviewer
#0 lore raw

v2 cover Add core wide metric literal

It is possible to optimize metrics when all SMT threads (CPUs) on a core are measuring events in system wide mode. For example, TMA metrics [1] defines CORE_CLKS for Sandybrdige as:

if SMT is disabled:
CPU_CLK_UNHALTED.THREAD
if SMT is enabled and recording on all SMT threads (for all processes):
CPU_CLK_UNHALTED.THREAD_ANY / 2
if SMT is enabled and not recording on all SMT threads:
(CPU_CLK_UNHALTED.THREAD/2)* (1+CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE/CPU_CLK_UNHALTED.REF_XCLK )

That is two more events are necessary when not gathering counts on all SMT threads. To distinguish all SMT threads on a core vs system wide (all CPUs) call the new property core wide.

As this literal requires the user requested CPUs and system wide to be present, the parsing of metrics is delayed until after command line option processing. As events are used to compute the evlist maps, and metrics create events, the data for core wide must come from the target.

This patch series doesn't correct the Intel metrics to use #core_wide, which will be done in follow up work. To see the two behaviors currently you need an Intel CPU between Sandybridge and before Icelake, then compare the events for tma_backend_bound_percent and Backend_Bound_SMT where the former assumes recording on all SMT threads and the latter assumes not recording on all SMT threads. The future work will just have a single backend bound metric for both cases determined using #core_wide.

[1] https://download.01.org/perfmon/TMA_Metrics.xlsx Note, #EBS_Mode is false when recording on all SMT threads and all processes which is #core_wide true in this change.

v2. Add error handling for ENOMEM to more strdup cases as suggested by
Arnaldo. Init the shadow stats if running "perf stat report", issue caught by the stat shell test.

Ian Rogers (7):
perf metric: Return early if no CPU PMU table exists perf expr: Move the scanner_ctx into the parse_ctx perf smt: Compute SMT from topology
perf topology: Add core_wide
perf stat: Delay metric parsing
perf metrics: Wire up core_wide
perf test: Add basic core_wide expression test

 tools/perf/builtin-stat.c     |  66 +++++++++++++----
 tools/perf/tests/expr.c       |  37 +++++++---
 tools/perf/util/cputopo.c     |  61 +++++++++++++++
 tools/perf/util/cputopo.h     |   5 ++
 tools/perf/util/expr.c        |  29 +++++---
 tools/perf/util/expr.h        |  14 ++--
 tools/perf/util/expr.l        |   6 +-
 tools/perf/util/metricgroup.c | 135 ++++++++++++++++++++++++----------
 tools/perf/util/metricgroup.h |   4 +-
 tools/perf/util/smt.c         | 109 ++++++---------------------
 tools/perf/util/smt.h         |  12 ++-
 tools/perf/util/stat-shadow.c |  13 +++-
 tools/perf/util/stat.h        |   2 +
 13 files changed, 318 insertions(+), 175 deletions(-)
Signature · 1 line
2.37.2.672.g94769d06f0-goog
author reviewer
#1 lore raw

PATCH v2 1/7 perf metric: Return early if no CPU PMU table exists

Previous behavior is to segfault if there is no CPU PMU table and a metric is sought. To reproduce compile with NO_JEVENTS=1 then request a metric, for example, "perf stat -M IPC true".

Fixes 00facc760903 ("perf jevents: Switch build to use jevents.py")
---
 tools/perf/util/metricgroup.c | 3 +++
 1 file changed, 3 insertions(+)
tools/perf/util/metricgroup.c +3 -0
index ad5cacdecd81..18aae040d61d 100644
@@ -1655,6 +1655,9 @@ int metricgroup__parse_groups(const struct option *opt,
 	struct evlist *perf_evlist = *(struct evlist **)opt->value;
 	const struct pmu_events_table *table = pmu_events_table__find();
 
+	if (!table)
+		return -EINVAL;
+
 	return parse_groups(perf_evlist, str, metric_no_group,
 			    metric_no_merge, NULL, metric_events, table);
 }
Signature · 1 line
2.37.2.672.g94769d06f0-goog
author reviewer
#2 lore raw

PATCH v2 2/7 perf expr: Move the scanner_ctx into the parse_ctx

In reply to Ian Rogers

We currently maintain the two independently and copy from one to the other. This is a burden when additional scanner context values are necessary, so combine them.

---
 tools/perf/tests/expr.c       |  2 +-
 tools/perf/util/expr.c        |  7 ++-----
 tools/perf/util/expr.h        | 10 +++++-----
 tools/perf/util/metricgroup.c |  4 ++--
 tools/perf/util/stat-shadow.c |  2 +-
 5 files changed, 11 insertions(+), 14 deletions(-)
tools/perf/tests/expr.c +1 -1
index 2efe9e3a63b8..7ca5e37de560 100644
@@ -133,7 +133,7 @@ static int test__expr(struct test_suite *t __maybe_unused, int subtest __maybe_u
 						    (void **)&val_ptr));
 
 	expr__ctx_clear(ctx);
-	ctx->runtime = 3;
+	ctx->sctx.runtime = 3;
 	TEST_ASSERT_VAL("find ids",
 			expr__find_ids("EVENT1\\,param\\=?@ + EVENT2\\,param\\=?@",
 					NULL, ctx) == 0);
tools/perf/util/expr.c +2 -5
index c15a9852fa41..00bde682e743 100644
@@ -310,7 +310,7 @@ struct expr_parse_ctx *expr__ctx_new(void)
 		free(ctx);
 		return NULL;
 	}
-	ctx->runtime = 0;
+	ctx->sctx.runtime = 0;
 
 	return ctx;
 }
@@ -344,16 +344,13 @@ static int
 __expr__parse(double *val, struct expr_parse_ctx *ctx, const char *expr,
 	      bool compute_ids)
 {
-	struct expr_scanner_ctx scanner_ctx = {
-		.runtime = ctx->runtime,
-	};
 	YY_BUFFER_STATE buffer;
 	void *scanner;
 	int ret;
 
 	pr_debug2("parsing metric: %s\n", expr);
 
-	ret = expr_lex_init_extra(&scanner_ctx, &scanner);
+	ret = expr_lex_init_extra(&ctx->sctx, &scanner);
 	if (ret)
 		return ret;
 
tools/perf/util/expr.h +5 -5
index 0403a92d9dcc..07af3d438eb2 100644
@@ -10,17 +10,17 @@
 
 struct metric_ref;
 
+struct expr_scanner_ctx {
+	int runtime;
+};
+
 struct expr_parse_ctx {
 	struct hashmap	*ids;
-	int runtime;
+	struct expr_scanner_ctx sctx;
 };
 
 struct expr_id_data;
 
-struct expr_scanner_ctx {
-	int runtime;
-};
-
 struct hashmap *ids__new(void);
 void ids__free(struct hashmap *ids);
 int ids__insert(struct hashmap *ids, const char *id);
tools/perf/util/metricgroup.c +2 -2
index 18aae040d61d..b144c3e35264 100644
@@ -215,7 +215,7 @@ static struct metric *metric__new(const struct pmu_event *pe,
 	}
 	m->metric_expr = pe->metric_expr;
 	m->metric_unit = pe->unit;
-	m->pctx->runtime = runtime;
+	m->pctx->sctx.runtime = runtime;
 	m->has_constraint = metric_no_group || metricgroup__has_constraint(pe);
 	m->metric_refs = NULL;
 	m->evlist = NULL;
@@ -1626,7 +1626,7 @@ static int parse_groups(struct evlist *perf_evlist, const char *str,
 		}
 		expr->metric_unit = m->metric_unit;
 		expr->metric_events = metric_events;
-		expr->runtime = m->pctx->runtime;
+		expr->runtime = m->pctx->sctx.runtime;
 		list_add(&expr->nd, &me->head);
 	}
 
tools/perf/util/stat-shadow.c +1 -1
index 788ce5e46470..815af948abb9 100644
@@ -911,7 +911,7 @@ static void generic_metric(struct perf_stat_config *config,
 	if (!pctx)
 		return;
 
-	pctx->runtime = runtime;
+	pctx->sctx.runtime = runtime;
 	i = prepare_metric(metric_events, metric_refs, pctx, cpu_map_idx, st);
 	if (i < 0) {
 		expr__ctx_free(pctx);
Signature · 1 line
2.37.2.672.g94769d06f0-goog
author reviewer
#3 lore raw

PATCH v2 3/7 perf smt: Compute SMT from topology

In reply to Ian Rogers

The topology records sibling threads. Rather than computing SMT using siblings in sysfs, reuse the values in topology. This only applies when the file smt/active isn't available.

---
 tools/perf/tests/expr.c   | 24 ++++++----
 tools/perf/util/cputopo.c | 15 +++++++
 tools/perf/util/cputopo.h |  2 +
 tools/perf/util/expr.c    |  9 ++--
 tools/perf/util/smt.c     | 95 ++++-----------------------------------
 tools/perf/util/smt.h     |  5 ++-
 6 files changed, 49 insertions(+), 101 deletions(-)
tools/perf/tests/expr.c +15 -9
index 7ca5e37de560..db736ed49556 100644
@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0
+#include "util/cputopo.h"
 #include "util/debug.h"
 #include "util/expr.h"
 #include "util/header.h"
@@ -154,15 +155,20 @@ static int test__expr(struct test_suite *t __maybe_unused, int subtest __maybe_u
 						    (void **)&val_ptr));
 
 	/* Only EVENT1 or EVENT2 need be measured depending on the value of smt_on. */
-	expr__ctx_clear(ctx);
-	TEST_ASSERT_VAL("find ids",
-			expr__find_ids("EVENT1 if #smt_on else EVENT2",
-				NULL, ctx) == 0);
-	TEST_ASSERT_VAL("find ids", hashmap__size(ctx->ids) == 1);
-	TEST_ASSERT_VAL("find ids", hashmap__find(ctx->ids,
-						  smt_on() ? "EVENT1" : "EVENT2",
-						  (void **)&val_ptr));
-
+	{
+		struct cpu_topology *topology = cpu_topology__new();
+		bool smton = smt_on(topology);
+
+		cpu_topology__delete(topology);
+		expr__ctx_clear(ctx);
+		TEST_ASSERT_VAL("find ids",
+				expr__find_ids("EVENT1 if #smt_on else EVENT2",
+					NULL, ctx) == 0);
+		TEST_ASSERT_VAL("find ids", hashmap__size(ctx->ids) == 1);
+		TEST_ASSERT_VAL("find ids", hashmap__find(ctx->ids,
+							  smton ? "EVENT1" : "EVENT2",
+							  (void **)&val_ptr));
+	}
 	/* The expression is a constant 1.0 without needing to evaluate EVENT1. */
 	expr__ctx_clear(ctx);
 	TEST_ASSERT_VAL("find ids",
tools/perf/util/cputopo.c +15 -0
index d275d843c155..511002e52714 100644
@@ -157,6 +157,21 @@ void cpu_topology__delete(struct cpu_topology *tp)
 	free(tp);
 }
 
+bool cpu_topology__smt_on(const struct cpu_topology *topology)
+{
+	for (u32 i = 0; i < topology->core_cpus_lists; i++) {
+		const char *cpu_list = topology->core_cpus_list[i];
+
+		/*
+		 * If there is a need to separate siblings in a core then SMT is
+		 * enabled.
+		 */
+		if (strchr(cpu_list, ',') || strchr(cpu_list, '-'))
+			return true;
+	}
+	return false;
+}
+
 static bool has_die_topology(void)
 {
 	char filename[MAXPATHLEN];
tools/perf/util/cputopo.h +2 -0
index 854e18f9041e..469db775a13c 100644
@@ -58,6 +58,8 @@ struct hybrid_topology {
 
 struct cpu_topology *cpu_topology__new(void);
 void cpu_topology__delete(struct cpu_topology *tp);
+/* Determine from the core list whether SMT was enabled. */
+bool cpu_topology__smt_on(const struct cpu_topology *topology);
 
 struct numa_topology *numa_topology__new(void);
 void numa_topology__delete(struct numa_topology *tp);
tools/perf/util/expr.c +4 -5
index 00bde682e743..8aa7dafa18b3 100644
@@ -412,11 +412,6 @@ double expr__get_literal(const char *literal)
 	static struct cpu_topology *topology;
 	double result = NAN;
 
-	if (!strcasecmp("#smt_on", literal)) {
-		result = smt_on() > 0 ? 1.0 : 0.0;
-		goto out;
-	}
-
 	if (!strcmp("#num_cpus", literal)) {
 		result = cpu__max_present_cpu().cpu;
 		goto out;
@@ -440,6 +435,10 @@ double expr__get_literal(const char *literal)
 			goto out;
 		}
 	}
+	if (!strcasecmp("#smt_on", literal)) {
+		result = smt_on(topology) ? 1.0 : 0.0;
+		goto out;
+	}
 	if (!strcmp("#num_packages", literal)) {
 		result = topology->package_cpus_lists;
 		goto out;
tools/perf/util/smt.c +9 -86

109 lines not on this page · raw message

tools/perf/util/smt.h +4 -1
index a98d65808f6a..e26999c6b8d4 100644
@@ -2,6 +2,9 @@
 #ifndef __SMT_H
 #define __SMT_H 1
 
-int smt_on(void);
+struct cpu_topology;
+
+/* Returns true if SMT (aka hyperthreading) is enabled. */
+bool smt_on(const struct cpu_topology *topology);
 
 #endif /* __SMT_H */
Signature · 1 line
2.37.2.672.g94769d06f0-goog
author reviewer
#4 lore raw

PATCH v2 4/7 perf topology: Add core_wide

In reply to Ian Rogers

It is possible to optimize metrics when all SMT threads (CPUs) on a core are measuring events in system wide mode. For example, TMA metrics defines CORE_CLKS for Sandybrdige as:

if SMT is disabled:
CPU_CLK_UNHALTED.THREAD
if SMT is enabled and recording on all SMT threads:
CPU_CLK_UNHALTED.THREAD_ANY / 2
if SMT is enabled and not recording on all SMT threads:
(CPU_CLK_UNHALTED.THREAD/2)* (1+CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE/CPU_CLK_UNHALTED.REF_XCLK )

That is two more events are necessary when not gathering counts on all SMT threads. To distinguish all SMT threads on a core vs system wide (all CPUs) call the new property core wide. Add a core wide test that determines the property from user requested CPUs, the topology and system wide. System wide is required as other processes running on a SMT thread will change the counts.

---
 tools/perf/util/cputopo.c | 46 +++++++++++++++++++++++++++++++++++++++
 tools/perf/util/cputopo.h |  3 +++
 tools/perf/util/smt.c     | 14 ++++++++++++
 tools/perf/util/smt.h     |  7 ++++++
 4 files changed, 70 insertions(+)
tools/perf/util/cputopo.c +46 -0
index 511002e52714..1a3ff6449158 100644
@@ -172,6 +172,52 @@ bool cpu_topology__smt_on(const struct cpu_topology *topology)
 	return false;
 }
 
+bool cpu_topology__core_wide(const struct cpu_topology *topology,
+			     const char *user_requested_cpu_list)
+{
+	struct perf_cpu_map *user_requested_cpus;
+
+	/*
+	 * If user_requested_cpu_list is empty then all CPUs are recorded and so
+	 * core_wide is true.
+	 */
+	if (!user_requested_cpu_list)
+		return true;
+
+	user_requested_cpus = perf_cpu_map__new(user_requested_cpu_list);
+	/* Check that every user requested CPU is the complete set of SMT threads on a core. */
+	for (u32 i = 0; i < topology->core_cpus_lists; i++) {
+		const char *core_cpu_list = topology->core_cpus_list[i];
+		struct perf_cpu_map *core_cpus = perf_cpu_map__new(core_cpu_list);
+		struct perf_cpu cpu;
+		int idx;
+		bool has_first, first = true;
+
+		perf_cpu_map__for_each_cpu(cpu, idx, core_cpus) {
+			if (first) {
+				has_first = perf_cpu_map__has(user_requested_cpus, cpu);
+				first = false;
+			} else {
+				/*
+				 * If the first core CPU is user requested then
+				 * all subsequent CPUs in the core must be user
+				 * requested too. If the first CPU isn't user
+				 * requested then none of the others must be
+				 * too.
+				 */
+				if (perf_cpu_map__has(user_requested_cpus, cpu) != has_first) {
+					perf_cpu_map__put(core_cpus);
+					perf_cpu_map__put(user_requested_cpus);
+					return false;
+				}
+			}
+		}
+		perf_cpu_map__put(core_cpus);
+	}
+	perf_cpu_map__put(user_requested_cpus);
+	return true;
+}
+
 static bool has_die_topology(void)
 {
 	char filename[MAXPATHLEN];
tools/perf/util/cputopo.h +3 -0
index 469db775a13c..969e5920a00e 100644
@@ -60,6 +60,9 @@ struct cpu_topology *cpu_topology__new(void);
 void cpu_topology__delete(struct cpu_topology *tp);
 /* Determine from the core list whether SMT was enabled. */
 bool cpu_topology__smt_on(const struct cpu_topology *topology);
+/* Are the sets of SMT siblings all enabled or all disabled in user_requested_cpus. */
+bool cpu_topology__core_wide(const struct cpu_topology *topology,
+			     const char *user_requested_cpu_list);
 
 struct numa_topology *numa_topology__new(void);
 void numa_topology__delete(struct numa_topology *tp);
tools/perf/util/smt.c +14 -0
index ce90c4ee4138..994e9e418227 100644
@@ -21,3 +21,17 @@ bool smt_on(const struct cpu_topology *topology)
 	cached = true;
 	return cached_result;
 }
+
+bool core_wide(bool system_wide, const char *user_requested_cpu_list,
+	       const struct cpu_topology *topology)
+{
+	/* If not everything running on a core is being recorded then we can't use core_wide. */
+	if (!system_wide)
+		return false;
+
+	/* Cheap case that SMT is disabled and therefore we're inherently core_wide. */
+	if (!smt_on(topology))
+		return true;
+
+	return cpu_topology__core_wide(topology, user_requested_cpu_list);
+}
tools/perf/util/smt.h +7 -0
index e26999c6b8d4..ae9095f2c38c 100644
@@ -7,4 +7,11 @@ struct cpu_topology;
 /* Returns true if SMT (aka hyperthreading) is enabled. */
 bool smt_on(const struct cpu_topology *topology);
 
+/*
+ * Returns true when system wide and all SMT threads for a core are in the
+ * user_requested_cpus map.
+ */
+bool core_wide(bool system_wide, const char *user_requested_cpu_list,
+	       const struct cpu_topology *topology);
+
 #endif /* __SMT_H */
Signature · 1 line
2.37.2.672.g94769d06f0-goog
maintainer
#5 lore raw

Re: [PATCH v2 4/7] perf topology: Add core_wide

Hi Ian,

Quoted 22 lines · Ian Rogers

It is possible to optimize metrics when all SMT threads (CPUs) on a core are measuring events in system wide mode. For example, TMA metrics defines CORE_CLKS for Sandybrdige as:

if SMT is disabled:
CPU_CLK_UNHALTED.THREAD
if SMT is enabled and recording on all SMT threads:
CPU_CLK_UNHALTED.THREAD_ANY / 2
if SMT is enabled and not recording on all SMT threads:
(CPU_CLK_UNHALTED.THREAD/2)* (1+CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE/CPU_CLK_UNHALTED.REF_XCLK )

That is two more events are necessary when not gathering counts on all SMT threads. To distinguish all SMT threads on a core vs system wide (all CPUs) call the new property core wide. Add a core wide test that determines the property from user requested CPUs, the topology and system wide. System wide is required as other processes running on a SMT thread will change the counts.

---

[SNIP]

Quoted 5 lines
tools/perf/util/smt.c +0 -0
index ce90c4ee4138..994e9e418227 100644

tools/perf/util/smt.c bool smt_on(const struct cpu_topology *topology) · line 30

Quoted 10 lines
tools/perf/util/smt.c +7 -0
@@ -21,3 +21,17 @@ bool smt_on(const struct cpu_topology *topology)
        cached = true;
        return cached_result;
 }
+
+bool core_wide(bool system_wide, const char *user_requested_cpu_list,
+              const struct cpu_topology *topology)
+{
+       /* If not everything running on a core is being recorded then we can't use core_wide. */
+       if (!system_wide)
+               return false;

I'm not sure if it's correct. Wouldn't it be ok if it runs on all threads in a core
even if system wide is off? I thought that's what the below code checks.

In fact I thought the opposite logic like

    if (system_wide)
        return true;

But it seems the code allows to have cpu_list in the system wide mode. Then it also needs to check the user requested cpus being NULL. (IMHO system_wide should be cleared when it has a cpu list...)

    if (system_wide && !user_requested_cpu_list)
        return true;

And if we have a target pointer, we could add this too.

    if (!target__has_cpu(target))
        return false;

Thanks,
Namhyung

Quoted 26 lines
tools/perf/util/smt.c +7 -0
+
+       /* Cheap case that SMT is disabled and therefore we're inherently core_wide. */
+       if (!smt_on(topology))
+               return true;
+
+       return cpu_topology__core_wide(topology, user_requested_cpu_list);
+}
tools/perf/util/smt.h +7 -1
index e26999c6b8d4..ae9095f2c38c 100644
@@ -7,4 +7,11 @@ struct cpu_topology;
 /* Returns true if SMT (aka hyperthreading) is enabled. */
 bool smt_on(const struct cpu_topology *topology);
 
+/*
+ * Returns true when system wide and all SMT threads for a core are in the
+ * user_requested_cpus map.
+ */
+bool core_wide(bool system_wide, const char *user_requested_cpu_list,
+              const struct cpu_topology *topology);
+
 #endif /* __SMT_H */
--

2.37.2.672.g94769d06f0-goog

author reviewer
#6 lore raw

Re: [PATCH v2 4/7] perf topology: Add core_wide

Quoted 59 lines · Namhyung Kim

Hi Ian,

Quoted 22 lines · Ian Rogers

It is possible to optimize metrics when all SMT threads (CPUs) on a core are measuring events in system wide mode. For example, TMA metrics defines CORE_CLKS for Sandybrdige as:

if SMT is disabled:
CPU_CLK_UNHALTED.THREAD
if SMT is enabled and recording on all SMT threads:
CPU_CLK_UNHALTED.THREAD_ANY / 2
if SMT is enabled and not recording on all SMT threads:
(CPU_CLK_UNHALTED.THREAD/2)* (1+CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE/CPU_CLK_UNHALTED.REF_XCLK )

That is two more events are necessary when not gathering counts on all SMT threads. To distinguish all SMT threads on a core vs system wide (all CPUs) call the new property core wide. Add a core wide test that determines the property from user requested CPUs, the topology and system wide. System wide is required as other processes running on a SMT thread will change the counts.

---

[SNIP]

Quoted 5 lines
tools/perf/util/smt.c +0 -0
index ce90c4ee4138..994e9e418227 100644

tools/perf/util/smt.c bool smt_on(const struct cpu_topology *topology) · line 30

Quoted 10 lines
tools/perf/util/smt.c +7 -0
@@ -21,3 +21,17 @@ bool smt_on(const struct cpu_topology *topology)
        cached = true;
        return cached_result;
 }
+
+bool core_wide(bool system_wide, const char *user_requested_cpu_list,
+              const struct cpu_topology *topology)
+{
+       /* If not everything running on a core is being recorded then we can't use core_wide. */
+       if (!system_wide)
+               return false;

I'm not sure if it's correct. Wouldn't it be ok if it runs on all threads in a core
even if system wide is off? I thought that's what the below code checks.

In fact I thought the opposite logic like

    if (system_wide)
        return true;

But it seems the code allows to have cpu_list in the system wide mode. Then it also needs to check the user requested cpus being NULL. (IMHO system_wide should be cleared when it has a cpu list...)

    if (system_wide && !user_requested_cpu_list)
        return true;
Quoted 7 lines

And if we have a target pointer, we could add this too.

    if (!target__has_cpu(target))
        return false;

Thanks,
Namhyung

Thanks Namhyung,

It may be correct or may not be without the system wide flag, and so I want to be conservative and say we need the flag. Let me provide more detail with an example:

I'm going to assume we want to measure how many slots there were for an SMT thread. In the "Count Domain" of TMA metrics before Icelake slots is a core wide metric, meaning that you are measuring >1 hyper thread. As we are measuring >1 hyper thread and we don't control the scheduling of the other hyperthread, the only valid mode is system wide on all CPUs, or all CPUs on a core (aka core wide in this patch set). However, the slots count domain information also says "Slots - ICL onwards or EBS_Mode before ICL" meaning the count domain is valid for an SMT thread. If I look at SkylakeX currently we have two metrics:

https://git.kernel.org/pub/scm/linux/kernel/git/acme/linux.git/tree/tools/perf/pmu-events/arch/x86/skylakex/skx-metrics.json?h=perf/core#n167

{
"BriefDescription": "Total issue-pipeline slots (per-Physical
Core till ICL; per-Logical Processor ICL onward)",
"MetricExpr": "4 * CPU_CLK_UNHALTED.THREAD", "MetricGroup": "TmaL1",
"MetricName": "SLOTS"
},
{
"BriefDescription": "Total issue-pipeline slots (per-Physical
Core till ICL; per-Logical Processor ICL onward)",

       "MetricExpr": "4 * ( ( CPU_CLK_UNHALTED.THREAD / 2 ) * ( 1 +
CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE / CPU_CLK_UNHALTED.REF_XCLK ) )",
       "MetricGroup": "TmaL1_SMT",
       "MetricName": "SLOTS_SMT"

},

The SLOTS metrics is going to compute a valid value if hyperthreading is disabled, in other metrics you will see (CPU_CLK_UNHALTED.THREAD_ANY / 2) where THREAD.ANY and THREAD are the same event encoding. The reason for the divide by 2 is to adjust the count down so that when we add the other hyperthreads count we get the core wide value in the aggregation - the perf event on the 2nd hyper thread isn't necessary, but that's a separate problem. SLOTS_SMT is funny so let's dig into it:
The 4 is the pipeline width.
CPU_CLK_UNHALTED.THREAD is defined as, "Counts the number of core cycles while the thread is not in a halt state.."
The divide by 2 is because of 2 hyperthreads.
The 1 is because we assume that half the slots are going to be given to our hyperthread.
The CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE / CPU_CLK_UNHALTED.REF_XCLK will give a ratio for how many cycles our SMT thread was the only one running, and so we got those slots from the other hyperthread.

With #core_wide we can have a single SLOTS metric of (new lines and // comments for clarity):

// If we're #core_wide with SMT and we know the work on both hyperthreads are being measured for all processes then use a single counter
(4 * CPU_CLK_UNHALTED.THREAD_ANY / 2
if #core_wide else
// We're not core wide so we need thread counters to adjust the slots metric based on the time this SMT thread is active
4 * ( CPU_CLK_UNHALTED.THREAD / 2 ) * ( 1 +
CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE / CPU_CLK_UNHALTED.REF_XCLK ) ) if #smt_on
// No hyper threading can just use the core wide counter else 4 * CPU_CLK_UNHALTED.THREAD

As this metric is a foundation for many others then there is a great deal of use for it and the current pre-Icelake computation is generally only valid if on the command line you happen to have specified a core wide set up - which is error prone.

Thanks,
Ian

Quoted 26 lines
Quoted 26 lines
tools/perf/util/smt.c +7 -0
+
+       /* Cheap case that SMT is disabled and therefore we're inherently core_wide. */
+       if (!smt_on(topology))
+               return true;
+
+       return cpu_topology__core_wide(topology, user_requested_cpu_list);
+}
tools/perf/util/smt.h +7 -1
index e26999c6b8d4..ae9095f2c38c 100644
@@ -7,4 +7,11 @@ struct cpu_topology;
 /* Returns true if SMT (aka hyperthreading) is enabled. */
 bool smt_on(const struct cpu_topology *topology);
 
+/*
+ * Returns true when system wide and all SMT threads for a core are in the
+ * user_requested_cpus map.
+ */
+bool core_wide(bool system_wide, const char *user_requested_cpu_list,
+              const struct cpu_topology *topology);
+
 #endif /* __SMT_H */
--

2.37.2.672.g94769d06f0-goog

maintainer
#7 lore raw

Re: [PATCH v2 4/7] perf topology: Add core_wide

Quoted 66 lines · Ian Rogers
Quoted 64 lines · Namhyung Kim

Hi Ian,

Quoted 22 lines · Ian Rogers

It is possible to optimize metrics when all SMT threads (CPUs) on a core are measuring events in system wide mode. For example, TMA metrics defines CORE_CLKS for Sandybrdige as:

if SMT is disabled:
CPU_CLK_UNHALTED.THREAD
if SMT is enabled and recording on all SMT threads:
CPU_CLK_UNHALTED.THREAD_ANY / 2
if SMT is enabled and not recording on all SMT threads:
(CPU_CLK_UNHALTED.THREAD/2)* (1+CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE/CPU_CLK_UNHALTED.REF_XCLK )

That is two more events are necessary when not gathering counts on all SMT threads. To distinguish all SMT threads on a core vs system wide (all CPUs) call the new property core wide. Add a core wide test that determines the property from user requested CPUs, the topology and system wide. System wide is required as other processes running on a SMT thread will change the counts.

---

[SNIP]

Quoted 5 lines
tools/perf/util/smt.c +0 -0
index ce90c4ee4138..994e9e418227 100644

tools/perf/util/smt.c bool smt_on(const struct cpu_topology *topology) · line 30

Quoted 10 lines
tools/perf/util/smt.c +7 -0
@@ -21,3 +21,17 @@ bool smt_on(const struct cpu_topology *topology)
        cached = true;
        return cached_result;
 }
+
+bool core_wide(bool system_wide, const char *user_requested_cpu_list,
+              const struct cpu_topology *topology)
+{
+       /* If not everything running on a core is being recorded then we can't use core_wide. */
+       if (!system_wide)
+               return false;

I'm not sure if it's correct. Wouldn't it be ok if it runs on all threads in a core
even if system wide is off? I thought that's what the below code checks.

In fact I thought the opposite logic like

    if (system_wide)
        return true;

But it seems the code allows to have cpu_list in the system wide mode. Then it also needs to check the user requested cpus being NULL. (IMHO system_wide should be cleared when it has a cpu list...)

    if (system_wide && !user_requested_cpu_list)
        return true;

And if we have a target pointer, we could add this too.

    if (!target__has_cpu(target))
        return false;
Quoted 8 lines
Quoted 2 lines

Thanks,
Namhyung

Thanks Namhyung,

It may be correct or may not be without the system wide flag, and so I want to be conservative and say we need the flag. Let me provide more detail with an example:

Ok.

Quoted 64 lines

I'm going to assume we want to measure how many slots there were for an SMT thread. In the "Count Domain" of TMA metrics before Icelake slots is a core wide metric, meaning that you are measuring >1 hyper thread. As we are measuring >1 hyper thread and we don't control the scheduling of the other hyperthread, the only valid mode is system wide on all CPUs, or all CPUs on a core (aka core wide in this patch set). However, the slots count domain information also says "Slots - ICL onwards or EBS_Mode before ICL" meaning the count domain is valid for an SMT thread. If I look at SkylakeX currently we have two metrics:

https://git.kernel.org/pub/scm/linux/kernel/git/acme/linux.git/tree/tools/perf/pmu-events/arch/x86/skylakex/skx-metrics.json?h=perf/core#n167

{
"BriefDescription": "Total issue-pipeline slots (per-Physical
Core till ICL; per-Logical Processor ICL onward)",
"MetricExpr": "4 * CPU_CLK_UNHALTED.THREAD", "MetricGroup": "TmaL1",
"MetricName": "SLOTS"
},
{
"BriefDescription": "Total issue-pipeline slots (per-Physical
Core till ICL; per-Logical Processor ICL onward)",

       "MetricExpr": "4 * ( ( CPU_CLK_UNHALTED.THREAD / 2 ) * ( 1 +
CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE / CPU_CLK_UNHALTED.REF_XCLK ) )",
       "MetricGroup": "TmaL1_SMT",
       "MetricName": "SLOTS_SMT"

},

The SLOTS metrics is going to compute a valid value if hyperthreading is disabled, in other metrics you will see (CPU_CLK_UNHALTED.THREAD_ANY / 2) where THREAD.ANY and THREAD are the same event encoding. The reason for the divide by 2 is to adjust the count down so that when we add the other hyperthreads count we get the core wide value in the aggregation - the perf event on the 2nd hyper thread isn't necessary, but that's a separate problem. SLOTS_SMT is funny so let's dig into it:
The 4 is the pipeline width.
CPU_CLK_UNHALTED.THREAD is defined as, "Counts the number of core cycles while the thread is not in a halt state.."
The divide by 2 is because of 2 hyperthreads.
The 1 is because we assume that half the slots are going to be given to our hyperthread.
The CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE / CPU_CLK_UNHALTED.REF_XCLK will give a ratio for how many cycles our SMT thread was the only one running, and so we got those slots from the other hyperthread.

With #core_wide we can have a single SLOTS metric of (new lines and // comments for clarity):

// If we're #core_wide with SMT and we know the work on both hyperthreads are being measured for all processes then use a single counter
(4 * CPU_CLK_UNHALTED.THREAD_ANY / 2
if #core_wide else
// We're not core wide so we need thread counters to adjust the slots metric based on the time this SMT thread is active
4 * ( CPU_CLK_UNHALTED.THREAD / 2 ) * ( 1 +
CPU_CLK_UNHALTED.ONE_THREAD_ACTIVE / CPU_CLK_UNHALTED.REF_XCLK ) ) if #smt_on
// No hyper threading can just use the core wide counter else 4 * CPU_CLK_UNHALTED.THREAD

Quoted 4 lines

As this metric is a foundation for many others then there is a great deal of use for it and the current pre-Icelake computation is generally only valid if on the command line you happen to have specified a core wide set up - which is error prone.

Thanks for the explanation. I understand why we need core_wide for accurate metrics. My concern was just to have a clear relationship between system-wide mode and user requested cpu list.

But I think it should be a separate thread, let me work on cpu map cleanups as we discussed earlier in:

https://lore.kernel.org/r/[email protected]/

Thanks,
Namhyung

author reviewer
#8 lore raw

PATCH v2 5/7 perf stat: Delay metric parsing

In reply to Ian Rogers

Having metric parsing as part of argument processing causes issues as flags like metric-no-group may be specified later. It also denies the opportunity to optimize the events on SMT systems where fewer events may be possible if we know the target is system-wide. Move metric parsing to after command line option parsing. Because of how stat runs this moves the parsing after record/report which fail to work with metrics currently anyway.

---
 tools/perf/builtin-stat.c     | 52 +++++++++++++++++++++++++----------
 tools/perf/util/metricgroup.c |  3 +-
 tools/perf/util/metricgroup.h |  2 +-
 3 files changed, 39 insertions(+), 18 deletions(-)
tools/perf/builtin-stat.c +37 -15
index 54cd29d07ca8..a59c23f4ffd2 100644
@@ -191,6 +191,7 @@ static bool			append_file;
 static bool			interval_count;
 static const char		*output_name;
 static int			output_fd;
+static char			*metrics;
 
 struct perf_stat {
 	bool			 record;
@@ -1148,14 +1149,23 @@ static int enable_metric_only(const struct option *opt __maybe_unused,
 	return 0;
 }
 
-static int parse_metric_groups(const struct option *opt,
+static int append_metric_groups(const struct option *opt __maybe_unused,
 			       const char *str,
 			       int unset __maybe_unused)
 {
-	return metricgroup__parse_groups(opt, str,
-					 stat_config.metric_no_group,
-					 stat_config.metric_no_merge,
-					 &stat_config.metric_events);
+	if (metrics) {
+		char *tmp;
+
+		if (asprintf(&tmp, "%s,%s", metrics, str) < 0)
+			return -ENOMEM;
+		free(metrics);
+		metrics = tmp;
+	} else {
+		metrics = strdup(str);
+		if (!metrics)
+			return -ENOMEM;
+	}
+	return 0;
 }
 
 static int parse_control_option(const struct option *opt,
@@ -1299,7 +1309,7 @@ static struct option stat_options[] = {
 			"measure SMI cost"),
 	OPT_CALLBACK('M', "metrics", &evsel_list, "metric/metric group list",
 		     "monitor specified metrics or metric groups (separated by ,)",
-		     parse_metric_groups),
+		     append_metric_groups),
 	OPT_BOOLEAN_FLAG(0, "all-kernel", &stat_config.all_kernel,
 			 "Configure all used events to run in kernel space.",
 			 PARSE_OPT_EXCLUSIVE),
@@ -1792,11 +1802,9 @@ static int add_default_attributes(void)
 		 * on an architecture test for such a metric name.
 		 */
 		if (metricgroup__has_metric("transaction")) {
-			struct option opt = { .value = &evsel_list };
-
-			return metricgroup__parse_groups(&opt, "transaction",
+			return metricgroup__parse_groups(evsel_list, "transaction",
 							 stat_config.metric_no_group,
-							stat_config.metric_no_merge,
+							 stat_config.metric_no_merge,
 							 &stat_config.metric_events);
 		}
 
@@ -2182,6 +2190,8 @@ static int __cmd_report(int argc, const char **argv)
 			input_name = "perf.data";
 	}
 
+	perf_stat__init_shadow_stats();
+
 	perf_stat.data.path = input_name;
 	perf_stat.data.mode = PERF_DATA_MODE_READ;
 
@@ -2261,8 +2271,6 @@ int cmd_stat(int argc, const char **argv)
 	argc = parse_options_subcommand(argc, argv, stat_options, stat_subcommands,
 					(const char **) stat_usage,
 					PARSE_OPT_STOP_AT_NON_OPTION);
-	perf_stat__collect_metric_expr(evsel_list);
-	perf_stat__init_shadow_stats();
 
 	if (stat_config.csv_sep) {
 		stat_config.csv_output = true;
@@ -2429,6 +2437,23 @@ int cmd_stat(int argc, const char **argv)
 			target.system_wide = true;
 	}
 
+	if ((stat_config.aggr_mode == AGGR_THREAD) && (target.system_wide))
+		target.per_thread = true;
+
+	/*
+	 * Metric parsing needs to be delayed as metrics may optimize events
+	 * knowing the target is system-wide.
+	 */
+	if (metrics) {
+		metricgroup__parse_groups(evsel_list, metrics,
+					stat_config.metric_no_group,
+					stat_config.metric_no_merge,
+					&stat_config.metric_events);
+		zfree(&metrics);
+	}
+	perf_stat__collect_metric_expr(evsel_list);
+	perf_stat__init_shadow_stats();
+
 	if (add_default_attributes())
 		goto out;
 
@@ -2448,9 +2473,6 @@ int cmd_stat(int argc, const char **argv)
 		}
 	}
 
-	if ((stat_config.aggr_mode == AGGR_THREAD) && (target.system_wide))
-		target.per_thread = true;
-
 	if (evlist__fix_hybrid_cpus(evsel_list, target.cpu_list)) {
 		pr_err("failed to use cpu list %s\n", target.cpu_list);
 		goto out;
tools/perf/util/metricgroup.c +1 -2
index b144c3e35264..9151346a16ab 100644
@@ -1646,13 +1646,12 @@ static int parse_groups(struct evlist *perf_evlist, const char *str,
 	return ret;
 }
 
-int metricgroup__parse_groups(const struct option *opt,
+int metricgroup__parse_groups(struct evlist *perf_evlist,
 			      const char *str,
 			      bool metric_no_group,
 			      bool metric_no_merge,
 			      struct rblist *metric_events)
 {
-	struct evlist *perf_evlist = *(struct evlist **)opt->value;
 	const struct pmu_events_table *table = pmu_events_table__find();
 
 	if (!table)
tools/perf/util/metricgroup.h +1 -1
index 016b3b1a289a..af9ceadaec0f 100644
@@ -64,7 +64,7 @@ struct metric_expr {
 struct metric_event *metricgroup__lookup(struct rblist *metric_events,
 					 struct evsel *evsel,
 					 bool create);
-int metricgroup__parse_groups(const struct option *opt,
+int metricgroup__parse_groups(struct evlist *perf_evlist,
 			      const char *str,
 			      bool metric_no_group,
 			      bool metric_no_merge,
Signature · 1 line
2.37.2.672.g94769d06f0-goog
author reviewer
#9 lore raw

PATCH v2 6/7 perf metrics: Wire up core_wide

In reply to Ian Rogers

Pass state necessary for core_wide into the expression parser. Add system_wide and user_requested_cpu_list to perf_stat_config to make it available at display time. evlist isn't used as the evlist__create_maps, that computes user_requested_cpus, needs the list of events which is generated by the metric.

---
 tools/perf/builtin-stat.c     |  14 ++++
 tools/perf/util/expr.c        |  13 +++-
 tools/perf/util/expr.h        |   4 +-
 tools/perf/util/expr.l        |   6 +-
 tools/perf/util/metricgroup.c | 125 ++++++++++++++++++++++++----------
 tools/perf/util/metricgroup.h |   2 +
 tools/perf/util/stat-shadow.c |  11 ++-
 tools/perf/util/stat.h        |   2 +
 8 files changed, 134 insertions(+), 43 deletions(-)
tools/perf/builtin-stat.c +14 -0
index a59c23f4ffd2..35185ee1243e 100644
@@ -1805,6 +1805,8 @@ static int add_default_attributes(void)
 			return metricgroup__parse_groups(evsel_list, "transaction",
 							 stat_config.metric_no_group,
 							 stat_config.metric_no_merge,
+							 stat_config.user_requested_cpu_list,
+							 stat_config.system_wide,
 							 &stat_config.metric_events);
 		}
 
@@ -2440,6 +2442,15 @@ int cmd_stat(int argc, const char **argv)
 	if ((stat_config.aggr_mode == AGGR_THREAD) && (target.system_wide))
 		target.per_thread = true;
 
+	stat_config.system_wide = target.system_wide;
+	if (target.cpu_list) {
+		stat_config.user_requested_cpu_list = strdup(target.cpu_list);
+		if (!stat_config.user_requested_cpu_list) {
+			status = -ENOMEM;
+			goto out;
+		}
+	}
+
 	/*
 	 * Metric parsing needs to be delayed as metrics may optimize events
 	 * knowing the target is system-wide.
@@ -2448,6 +2459,8 @@ int cmd_stat(int argc, const char **argv)
 		metricgroup__parse_groups(evsel_list, metrics,
 					stat_config.metric_no_group,
 					stat_config.metric_no_merge,
+					stat_config.user_requested_cpu_list,
+					stat_config.system_wide,
 					&stat_config.metric_events);
 		zfree(&metrics);
 	}
@@ -2638,6 +2651,7 @@ int cmd_stat(int argc, const char **argv)
 		iostat_release(evsel_list);
 
 	zfree(&stat_config.walltime_run);
+	zfree(&stat_config.user_requested_cpu_list);
 
 	if (smi_cost && smi_reset)
 		sysfs__write_int(FREEZE_ON_SMI_PATH, 0);
tools/perf/util/expr.c +12 -1
index 8aa7dafa18b3..c6827900f8d3 100644
@@ -310,7 +310,9 @@ struct expr_parse_ctx *expr__ctx_new(void)
 		free(ctx);
 		return NULL;
 	}
+	ctx->sctx.user_requested_cpu_list = NULL;
 	ctx->sctx.runtime = 0;
+	ctx->sctx.system_wide = false;
 
 	return ctx;
 }
@@ -332,6 +334,10 @@ void expr__ctx_free(struct expr_parse_ctx *ctx)
 	struct hashmap_entry *cur;
 	size_t bkt;
 
+	if (!ctx)
+		return;
+
+	free(ctx->sctx.user_requested_cpu_list);
 	hashmap__for_each_entry(ctx->ids, cur, bkt) {
 		free((char *)cur->key);
 		free(cur->value);
@@ -407,7 +413,7 @@ double arch_get_tsc_freq(void)
 }
 #endif
 
-double expr__get_literal(const char *literal)
+double expr__get_literal(const char *literal, const struct expr_scanner_ctx *ctx)
 {
 	static struct cpu_topology *topology;
 	double result = NAN;
@@ -439,6 +445,11 @@ double expr__get_literal(const char *literal)
 		result = smt_on(topology) ? 1.0 : 0.0;
 		goto out;
 	}
+	if (!strcmp("#core_wide", literal)) {
+		result = core_wide(ctx->system_wide, ctx->user_requested_cpu_list, topology)
+			? 1.0 : 0.0;
+		goto out;
+	}
 	if (!strcmp("#num_packages", literal)) {
 		result = topology->package_cpus_lists;
 		goto out;
tools/perf/util/expr.h +3 -1
index 07af3d438eb2..d6c1668dc1a0 100644
@@ -11,7 +11,9 @@
 struct metric_ref;
 
 struct expr_scanner_ctx {
+	char *user_requested_cpu_list;
 	int runtime;
+	bool system_wide;
 };
 
 struct expr_parse_ctx {
@@ -55,6 +57,6 @@ int expr__find_ids(const char *expr, const char *one,
 
 double expr_id_data__value(const struct expr_id_data *data);
 double expr_id_data__source_count(const struct expr_id_data *data);
-double expr__get_literal(const char *literal);
+double expr__get_literal(const char *literal, const struct expr_scanner_ctx *ctx);
 
 #endif
tools/perf/util/expr.l +3 -3
index 4dc8edbfd9ce..0168a9637330 100644
@@ -79,11 +79,11 @@ static int str(yyscan_t scanner, int token, int runtime)
 	return token;
 }
 
-static int literal(yyscan_t scanner)
+static int literal(yyscan_t scanner, const struct expr_scanner_ctx *sctx)
 {
 	YYSTYPE *yylval = expr_get_lval(scanner);
 
-	yylval->num = expr__get_literal(expr_get_text(scanner));
+	yylval->num = expr__get_literal(expr_get_text(scanner), sctx);
 	if (isnan(yylval->num))
 		return EXPR_ERROR;
 
@@ -108,7 +108,7 @@ min		{ return MIN; }
 if		{ return IF; }
 else		{ return ELSE; }
 source_count	{ return SOURCE_COUNT; }
-{literal}	{ return literal(yyscanner); }
+{literal}	{ return literal(yyscanner, sctx); }
 {number}	{ return value(yyscanner); }
 {symbol}	{ return str(yyscanner, ID, sctx->runtime); }
 "|"		{ return '|'; }
tools/perf/util/metricgroup.c +90 -35

319 lines not on this page · raw message

tools/perf/util/metricgroup.h +2 -0
index af9ceadaec0f..732d3a0d3334 100644
@@ -68,6 +68,8 @@ int metricgroup__parse_groups(struct evlist *perf_evlist,
 			      const char *str,
 			      bool metric_no_group,
 			      bool metric_no_merge,
+			      const char *user_requested_cpu_list,
+			      bool system_wide,
 			      struct rblist *metric_events);
 int metricgroup__parse_groups_test(struct evlist *evlist,
 				   const struct pmu_events_table *table,
tools/perf/util/stat-shadow.c +8 -3
index 815af948abb9..9e1eddeff21b 100644
@@ -911,7 +911,10 @@ static void generic_metric(struct perf_stat_config *config,
 	if (!pctx)
 		return;
 
+	if (config->user_requested_cpu_list)
+		pctx->sctx.user_requested_cpu_list = strdup(config->user_requested_cpu_list);
 	pctx->sctx.runtime = runtime;
+	pctx->sctx.system_wide = config->system_wide;
 	i = prepare_metric(metric_events, metric_refs, pctx, cpu_map_idx, st);
 	if (i < 0) {
 		expr__ctx_free(pctx);
@@ -1304,7 +1307,8 @@ void perf_stat__print_shadow_stats(struct perf_stat_config *config,
 				core_bound * 100.);
 	} else if (evsel->metric_expr) {
 		generic_metric(config, evsel->metric_expr, evsel->metric_events, NULL,
-				evsel->name, evsel->metric_name, NULL, 1, cpu_map_idx, out, st);
+			       evsel->name, evsel->metric_name, NULL, 1,
+			       cpu_map_idx, out, st);
 	} else if (runtime_stat_n(st, STAT_NSECS, cpu_map_idx, &rsd) != 0) {
 		char unit = ' ';
 		char unit_buf[10] = "/sec";
@@ -1329,8 +1333,9 @@ void perf_stat__print_shadow_stats(struct perf_stat_config *config,
 			if (num++ > 0)
 				out->new_line(config, ctxp);
 			generic_metric(config, mexp->metric_expr, mexp->metric_events,
-					mexp->metric_refs, evsel->name, mexp->metric_name,
-					mexp->metric_unit, mexp->runtime, cpu_map_idx, out, st);
+				       mexp->metric_refs, evsel->name, mexp->metric_name,
+				       mexp->metric_unit, mexp->runtime,
+				       cpu_map_idx, out, st);
 		}
 	}
 	if (num == 0)
tools/perf/util/stat.h +2 -0
index 668250022f8c..72713b344b79 100644
@@ -141,6 +141,8 @@ struct perf_stat_config {
 	bool			 stop_read_counter;
 	bool			 quiet;
 	bool			 iostat_run;
+	char			 *user_requested_cpu_list;
+	bool			 system_wide;
 	FILE			*output;
 	unsigned int		 interval;
 	unsigned int		 timeout;
Signature · 1 line
2.37.2.672.g94769d06f0-goog
author reviewer
#10 lore raw

PATCH v2 7/7 perf test: Add basic core_wide expression test

In reply to Ian Rogers

Add basic test for coverage, similar to #smt_on.

---
 tools/perf/tests/expr.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)
tools/perf/tests/expr.c +13 -0
index db736ed49556..8bd719766814 100644
@@ -158,6 +158,9 @@ static int test__expr(struct test_suite *t __maybe_unused, int subtest __maybe_u
 	{
 		struct cpu_topology *topology = cpu_topology__new();
 		bool smton = smt_on(topology);
+		bool corewide = core_wide(/*system_wide=*/false,
+					  /*user_requested_cpus=*/false,
+					  topology);
 
 		cpu_topology__delete(topology);
 		expr__ctx_clear(ctx);
@@ -168,6 +171,16 @@ static int test__expr(struct test_suite *t __maybe_unused, int subtest __maybe_u
 		TEST_ASSERT_VAL("find ids", hashmap__find(ctx->ids,
 							  smton ? "EVENT1" : "EVENT2",
 							  (void **)&val_ptr));
+
+		expr__ctx_clear(ctx);
+		TEST_ASSERT_VAL("find ids",
+				expr__find_ids("EVENT1 if #core_wide else EVENT2",
+					NULL, ctx) == 0);
+		TEST_ASSERT_VAL("find ids", hashmap__size(ctx->ids) == 1);
+		TEST_ASSERT_VAL("find ids", hashmap__find(ctx->ids,
+							  corewide ? "EVENT1" : "EVENT2",
+							  (void **)&val_ptr));
+
 	}
 	/* The expression is a constant 1.0 without needing to evaluate EVENT1. */
 	expr__ctx_clear(ctx);
Signature · 1 line
2.37.2.672.g94769d06f0-goog