perf stat: Add aggr_nr metric parser support

Introduce the `aggr_nr` function to the metric expression parser.
`aggr_nr` allows metric formulas to dynamically utilize the number of
aggregated targets (`aggr->nr`) instead of relying on the static
`source_count` (which represents the static socket or node count).

This adds the `AGGR_NR` token to the lexer and parser, updates the
expression parsing context helpers to store `aggr_nr`, and feeds
`aggr->nr` from the aggregation structure in `prepare_metric`.

Assisted-by: Gemini:gemini-3.1-pro-preview
Signed-off-by: Chun-Tse Shao <ctshao@google.com>
Tested-by: Zide Chen <zide.chen@intel.com>
Acked-by: Namhyung Kim <namhyung@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@linaro.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Leo Yan <leo.yan@arm.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Sandipan Das <sandipan.das@amd.com>
Cc: Thomas Falcon <thomas.falcon@intel.com>
Cc: Yang Li <yang.lee@linux.alibaba.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/util/expr.c b/tools/perf/util/expr.c
index 644769e927089ea1dd2f9252078c35a69fa48dce..232998fef72ba35cfa697f2d4237558f2faa5317 100644 (file)
--- a/tools/perf/util/expr.c
+++ b/tools/perf/util/expr.c
@@ -27,6 +27,7 @@ struct expr_id_data {
                struct {
                        double val;
                        int source_count;
+                       int aggr_nr;
                } val;
                struct {
                        double val;
@@ -151,8 +152,8 @@ int expr__add_id_val(struct expr_parse_ctx *ctx, const char *id, double val)
 }
 
 /* Caller must make sure id is allocated */
-int expr__add_id_val_source_count(struct expr_parse_ctx *ctx, const char *id,
-                                 double val, int source_count)
+int expr__add_id_val_source_count_aggr_nr(struct expr_parse_ctx *ctx, const char *id,
+                                         double val, int source_count, int aggr_nr)
 {
        struct expr_id_data *data_ptr = NULL, *old_data = NULL;
        char *old_key = NULL;
@@ -163,6 +164,7 @@ int expr__add_id_val_source_count(struct expr_parse_ctx *ctx, const char *id,
                return -ENOMEM;
        data_ptr->val.val = val;
        data_ptr->val.source_count = source_count;
+       data_ptr->val.aggr_nr = aggr_nr;
        data_ptr->kind = EXPR_ID_DATA__VALUE;
 
        ret = hashmap__set(ctx->ids, id, data_ptr, &old_key, &old_data);
@@ -171,12 +173,20 @@ int expr__add_id_val_source_count(struct expr_parse_ctx *ctx, const char *id,
        } else if (old_data) {
                data_ptr->val.val += old_data->val.val;
                data_ptr->val.source_count += old_data->val.source_count;
+               data_ptr->val.aggr_nr += old_data->val.aggr_nr;
        }
        free(old_key);
        free(old_data);
        return ret;
 }
 
+/* Caller must make sure id is allocated */
+int expr__add_id_val_source_count(struct expr_parse_ctx *ctx, const char *id,
+                                 double val, int source_count)
+{
+       return expr__add_id_val_source_count_aggr_nr(ctx, id, val, source_count, 1);
+}
+
 int expr__add_ref(struct expr_parse_ctx *ctx, struct metric_ref *ref)
 {
        struct expr_id_data *data_ptr = NULL, *old_data = NULL;
@@ -390,8 +400,16 @@ double expr_id_data__value(const struct expr_id_data *data)
 
 double expr_id_data__source_count(const struct expr_id_data *data)
 {
-       assert(data->kind == EXPR_ID_DATA__VALUE);
-       return data->val.source_count;
+       if (data->kind == EXPR_ID_DATA__VALUE)
+               return data->val.source_count;
+       return 1.0;
+}
+
+double expr_id_data__aggr_nr(const struct expr_id_data *data)
+{
+       if (data->kind == EXPR_ID_DATA__VALUE)
+               return data->val.aggr_nr;
+       return 1.0;
 }
 
 double expr__get_literal(const char *literal, const struct expr_scanner_ctx *ctx)

diff --git a/tools/perf/util/expr.h b/tools/perf/util/expr.h
index c0cec29ddc2985857acb12dc1afe3d00bdfbae46..ed12e4007d2dc9d9d9fb5bb4d01c713b85215bd9 100644 (file)
--- a/tools/perf/util/expr.h
+++ b/tools/perf/util/expr.h
@@ -36,7 +36,9 @@ void expr__del_id(struct expr_parse_ctx *ctx, const char *id);
 int expr__add_id(struct expr_parse_ctx *ctx, const char *id);
 int expr__add_id_val(struct expr_parse_ctx *ctx, const char *id, double val);
 int expr__add_id_val_source_count(struct expr_parse_ctx *ctx, const char *id,
-                               double val, int source_count);
+                                 double val, int source_count);
+int expr__add_id_val_source_count_aggr_nr(struct expr_parse_ctx *ctx, const char *id,
+                                         double val, int source_count, int aggr_nr);
 int expr__add_ref(struct expr_parse_ctx *ctx, struct metric_ref *ref);
 int expr__get_id(struct expr_parse_ctx *ctx, const char *id,
                 struct expr_id_data **data);
@@ -53,6 +55,8 @@ 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_id_data__aggr_nr(const struct expr_id_data *data);
+
 double expr__get_literal(const char *literal, const struct expr_scanner_ctx *ctx);
 double expr__has_event(const struct expr_parse_ctx *ctx, bool compute_ids, const char *id);
 double expr__strcmp_cpuid_str(const struct expr_parse_ctx *ctx, bool compute_ids, const char *id);

diff --git a/tools/perf/util/expr.l b/tools/perf/util/expr.l
index a2fc43159ee9562c756bcb3545106f8078ff459b..f16ccff278d06b2957fe393a99e04a4d38d918cc 100644 (file)
--- a/tools/perf/util/expr.l
+++ b/tools/perf/util/expr.l
@@ -121,6 +121,7 @@ min         { return MIN; }
 if             { return IF; }
 else           { return ELSE; }
 source_count   { return SOURCE_COUNT; }
+aggr_nr                { return AGGR_NR; }
 has_event      { return HAS_EVENT; }
 strcmp_cpuid_str       { return STRCMP_CPUID_STR; }
 NaN            { return nan_value(yyscanner); }

diff --git a/tools/perf/util/expr.y b/tools/perf/util/expr.y
index e364790babb51aa39d85ea621bcea6c8d6479f88..e20f649354cfcabe7a9cb442688374175ae01839 100644 (file)
--- a/tools/perf/util/expr.y
+++ b/tools/perf/util/expr.y
@@ -41,7 +41,7 @@ int expr_lex(YYSTYPE * yylval_param , void *yyscanner);
        } ids;
 }
 
-%token ID NUMBER MIN MAX IF ELSE LITERAL D_RATIO SOURCE_COUNT HAS_EVENT STRCMP_CPUID_STR EXPR_ERROR
+%token ID NUMBER MIN MAX IF ELSE LITERAL D_RATIO SOURCE_COUNT AGGR_NR HAS_EVENT STRCMP_CPUID_STR EXPR_ERROR
 %left MIN MAX IF
 %left '|'
 %left '^'
@@ -87,8 +87,14 @@ static struct ids union_expr(struct ids ids1, struct ids ids2)
        return result;
 }
 
+enum expr_id_kind {
+       EXPR_ID_KIND__VALUE,
+       EXPR_ID_KIND__SOURCE_COUNT,
+       EXPR_ID_KIND__AGGR_NR,
+};
+
 static struct ids handle_id(struct expr_parse_ctx *ctx, char *id,
-                           bool compute_ids, bool source_count)
+                           bool compute_ids, enum expr_id_kind kind)
 {
        struct ids result;
 
@@ -101,9 +107,12 @@ static struct ids handle_id(struct expr_parse_ctx *ctx, char *id,
 
                result.val = NAN;
                if (expr__resolve_id(ctx, id, &data) == 0) {
-                       result.val = source_count
-                               ? expr_id_data__source_count(data)
-                               : expr_id_data__value(data);
+                       if (kind == EXPR_ID_KIND__SOURCE_COUNT)
+                               result.val = expr_id_data__source_count(data);
+                       else if (kind == EXPR_ID_KIND__AGGR_NR)
+                               result.val = expr_id_data__aggr_nr(data);
+                       else
+                               result.val = expr_id_data__value(data);
                }
                result.ids = NULL;
                free(id);
@@ -201,8 +210,9 @@ expr: NUMBER
        $$.val = $1;
        $$.ids = NULL;
 }
-| ID                           { $$ = handle_id(ctx, $1, compute_ids, /*source_count=*/false); }
-| SOURCE_COUNT '(' ID ')'      { $$ = handle_id(ctx, $3, compute_ids, /*source_count=*/true); }
+| ID                           { $$ = handle_id(ctx, $1, compute_ids, EXPR_ID_KIND__VALUE); }
+| SOURCE_COUNT '(' ID ')'      { $$ = handle_id(ctx, $3, compute_ids, EXPR_ID_KIND__SOURCE_COUNT); }
+| AGGR_NR '(' ID ')'           { $$ = handle_id(ctx, $3, compute_ids, EXPR_ID_KIND__AGGR_NR); }
 | HAS_EVENT '(' ID ')'
 {
        $$.val = expr__has_event(ctx, compute_ids, $3);

diff --git a/tools/perf/util/stat-shadow.c b/tools/perf/util/stat-shadow.c
index bc2d44df7bafa4d55354b379d515490b76bf4d41..c17373bb0e1e7ab65b4dc471fe7f8c363d2d31ce 100644 (file)
--- a/tools/perf/util/stat-shadow.c
+++ b/tools/perf/util/stat-shadow.c
@@ -53,6 +53,7 @@ static int prepare_metric(struct perf_stat_config *config,
 
        for (i = 0; metric_events[i]; i++) {
                int source_count = 0, tool_aggr_idx;
+               int aggr_nr = 1;
                bool is_tool_time =
                        tool_pmu__is_time_event(config, metric_events[i], &tool_aggr_idx);
                struct perf_stat_evsel *ps = metric_events[i]->stats;
@@ -89,6 +90,7 @@ static int prepare_metric(struct perf_stat_config *config,
                         */
                        val = NAN;
                        source_count = 0;
+                       aggr_nr = 0;
                } else {
                        struct perf_stat_aggr *aggr =
                                &ps->aggr[is_tool_time ? tool_aggr_idx : aggr_idx];
@@ -96,6 +98,7 @@ static int prepare_metric(struct perf_stat_config *config,
                        if (aggr->counts.run == 0) {
                                val = NAN;
                                source_count = 0;
+                               aggr_nr = 0;
                        } else {
                                val = aggr->counts.val;
                                if (is_tool_time) {
@@ -104,13 +107,14 @@ static int prepare_metric(struct perf_stat_config *config,
                                }
                                if (!source_count)
                                        source_count = evsel__source_count(metric_events[i]);
+                               aggr_nr = aggr->nr ?: 1;
                        }
                }
                n = strdup(evsel__metric_id(metric_events[i]));
                if (!n)
                        return -ENOMEM;
 
-               expr__add_id_val_source_count(pctx, n, val, source_count);
+               expr__add_id_val_source_count_aggr_nr(pctx, n, val, source_count, aggr_nr);
        }
 
        for (int j = 0; metric_refs && metric_refs[j].metric_name; j++) {