From nobody Fri Jan 2 06:50:41 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4F758CDB482 for ; Sat, 14 Oct 2023 01:52:36 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232706AbjJNBwe (ORCPT ); Fri, 13 Oct 2023 21:52:34 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53992 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232730AbjJNBw1 (ORCPT ); Fri, 13 Oct 2023 21:52:27 -0400 Received: from mgamail.intel.com (mgamail.intel.com [134.134.136.65]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F41D8B7; Fri, 13 Oct 2023 18:52:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1697248345; x=1728784345; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=Ucms9PcDVzc6u5A1kJWl+5kF+z6+f70CH8rXovuIyGc=; b=Y2UfvpaqUupmXv+pBetGePWhYNhOqtx7S2e7e3GrFo5oiBe1uyQOh2T/ B466VuG0O+BtoyiPmvOyoBFRVnphyVfV0KmSG2fH6IWyibpoY7cOhOyWf a4fbg5WrwXIK39Vafhmi1htPUf7jXfEvjRBN8PE6Fmo0jVB7ugZJZbCRb vUdQQDwypYpJU08PNSRcLUGaGYt/VGtn/ZQ2FLHPYgGPw8lP4un4Bvh4z IaL9hc/ukwl5crWBeue4ObU2pwhnU5bF4MTetlmkRMYAApwzSflSWgSRb PkrRIiCZT8q6eiLBaY129E7PRt0ki7WSygdeQE6y0j4X9/x2JZHB4gMGf A==; X-IronPort-AV: E=McAfee;i="6600,9927,10862"; a="389154702" X-IronPort-AV: E=Sophos;i="6.03,223,1694761200"; d="scan'208";a="389154702" Received: from orsmga006.jf.intel.com ([10.7.209.51]) by orsmga103.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 13 Oct 2023 18:52:19 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10862"; a="731565676" X-IronPort-AV: E=Sophos;i="6.03,223,1694761200"; d="scan'208";a="731565676" Received: from b49691a75598.jf.intel.com ([10.54.34.22]) by orsmga006.jf.intel.com with ESMTP; 13 Oct 2023 18:52:19 -0700 From: weilin.wang@intel.com To: weilin.wang@intel.com, Ian Rogers , Peter Zijlstra , Ingo Molnar , Arnaldo Carvalho de Melo , Alexander Shishkin , Jiri Olsa , Namhyung Kim , Adrian Hunter , Kan Liang Cc: linux-perf-users@vger.kernel.org, linux-kernel@vger.kernel.org, Perry Taylor , Samantha Alt , Caleb Biggers , Mark Rutland , Yang Jihong Subject: [RFC PATCH v2 07/17] perf stat: Add functions to set counter bitmaps for hardware-grouping method Date: Fri, 13 Oct 2023 18:51:52 -0700 Message-Id: <20231014015202.1175377-8-weilin.wang@intel.com> X-Mailer: git-send-email 2.39.3 In-Reply-To: <20231014015202.1175377-1-weilin.wang@intel.com> References: <20231014015202.1175377-1-weilin.wang@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" From: Weilin Wang Add metricgroup__event_info data structure to represent an event in the metric grouping context; the list of counters and the PMU name an event should be collected with. Add functions to parse event counter info from pmu-events and generate a list of metricgroup__event_info data to prepare grouping. Signed-off-by: Weilin Wang --- tools/perf/util/metricgroup.c | 196 +++++++++++++++++++++++++++++++++- tools/perf/util/metricgroup.h | 27 +++++ 2 files changed, 220 insertions(+), 3 deletions(-) diff --git a/tools/perf/util/metricgroup.c b/tools/perf/util/metricgroup.c index 8d4e29eb1..6af8a7341 100644 --- a/tools/perf/util/metricgroup.c +++ b/tools/perf/util/metricgroup.c @@ -1432,6 +1432,182 @@ static int build_combined_expr_ctx(const struct lis= t_head *metric_list, return ret; } =20 +/** + * set_counter_bitmap - The counter bit mapping: [8-15,0-7], e.g. the GP0 = is the + * 8th bit and GP7 is the 1st bit in this 16-bits bitmap. It is helpful for + * assigning GP4-7 before GP0-3 because some events can be collected using= GP0-3 + * only on some platforms. + */ +static int set_counter_bitmap(int pos, unsigned long *bitmap) +{ + if (pos >=3D NR_COUNTERS || pos < 0) + return -EINVAL; + if (pos <=3D 7) + pos =3D TRANSFER_FIRST_BYTE(pos); + else + pos =3D TRANSFER_SEC_BYTE(pos); + *bitmap |=3D 1ul << pos; + return 0; +} + +static int parse_fixed_counter(const char *counter, + unsigned long *bitmap, + bool *fixed) +{ + int ret =3D -ENOENT; + //TODO: this pattern is different on some other platforms + const char *pattern =3D "Fixed counter "; + int pos =3D 0; + + if (!strncmp(counter, pattern, strlen(pattern))) { + pos =3D atoi(counter + strlen(pattern)); + ret =3D set_counter_bitmap(pos, bitmap); + if (ret) + return ret; + *fixed =3D true; + return 0; + } + return ret; +} + +/** + * parse_counter - Parse event counter info from pmu-events and set up bit= map + * accordingly. + * + * @counter: counter info string to be parsed. + * @bitmap: bitmap to set based on counter info parsed. + * @fixed: is set to true if the event uses fixed counter. + */ +static int parse_counter(const char *counter, + unsigned long *bitmap, + bool *fixed) +{ + int ret =3D 0; + char *p; + char *tok; + int pos =3D 0; + + ret =3D parse_fixed_counter(counter, bitmap, fixed); + // ret=3D=3D0 means matched with fixed counter + if (ret =3D=3D 0) + return ret; + + p =3D strdup(counter); + tok =3D strtok(p, ","); + if (!tok) + return -ENOENT; + + while (tok) { + pos =3D atoi(tok); + ret =3D set_counter_bitmap(pos, bitmap); + if (ret) + return ret; + tok =3D strtok(NULL, ","); + } + return 0; +} + +static struct metricgroup__event_info *event_info__new(const char *name, + const char *pmu_name, + const char *counter, + bool free_counter) +{ + int ret =3D 0; + char *bit_buf =3D malloc(NR_COUNTERS); + bool fixed_counter =3D false; + struct metricgroup__event_info *e; + + e =3D zalloc(sizeof(*e)); + if (!e) + return NULL; + if (!pmu_name) + pmu_name =3D "core"; + + e->name =3D name; + e->free_counter =3D free_counter; + e->pmu_name =3D strdup(pmu_name); + if (free_counter) { + ret =3D set_counter_bitmap(0, e->counters); + if (ret) + return NULL; + } else { + ret =3D parse_counter(counter, e->counters, &fixed_counter); + if (ret) + return NULL; + e->fixed_counter =3D fixed_counter; + } + + bitmap_scnprintf(e->counters, NR_COUNTERS, bit_buf, NR_COUNTERS); + pr_debug("Event %s requires pmu %s counter: %s bitmap %s, [pmu=3D%s]\n", + e->name, e->pmu_name, counter, bit_buf, pmu_name); + + return e; +} + +struct metricgroup__add_metric_event_data { + struct list_head *list; + /* pure event name, exclude umask and other info*/ + const char *event_name; + /* event name and umask if applicable*/ + const char *event_id; +}; + +static int metricgroup__add_metric_event_callback(const struct pmu_event *= pe, + const struct pmu_events_table *table __maybe_unused, + void *data) +{ + struct metricgroup__event_info *event; + struct metricgroup__add_metric_event_data *d =3D data; + + if (!strcasecmp(pe->name, d->event_name)) { + event =3D event_info__new(d->event_id, pe->pmu, pe->counter, /*free_coun= ter=3D*/false); + if (!event) + return -ENOMEM; + list_add(&event->nd, d->list); + } + + return 0; +} + +/** + * get_metricgroup_events - Find counter requirement of events from the + * pmu_events table + * @full_id: the full event identifiers. + * @table: pmu_events table that is searched for event data. + * @event_info_list: the list that the new event counter info added to. + */ +static int get_metricgroup_events(const char *full_id, + const struct pmu_events_table *table, + struct list_head *event_info_list) +{ + LIST_HEAD(list); + int ret =3D 0; + const char *id; + const char *rsep, *sep =3D strchr(full_id, '@'); + + if (sep) { + rsep =3D strchr(full_id, ','); + id =3D strndup(sep + 1, rsep - sep - 1); + if (ret) + goto out; + } else { + id =3D full_id; + } + { + struct metricgroup__add_metric_event_data data =3D { + .list =3D &list, + .event_name =3D id, + .event_id =3D full_id, + }; + ret =3D pmu_events_table_for_each_event(table, + metricgroup__add_metric_event_callback, &data); + } + +out: + list_splice(&list, event_info_list); + return ret; +} + /** * hw_aware_build_grouping - Build event groupings by reading counter * requirement of the events and counter available on the system from @@ -1445,9 +1621,25 @@ static int hw_aware_build_grouping(struct expr_parse= _ctx *ctx __maybe_unused, const char *modifier __maybe_unused) { int ret =3D 0; + struct hashmap_entry *cur; + LIST_HEAD(pmu_info_list); + LIST_HEAD(event_info_list); + size_t bkt; + const struct pmu_events_table *etable =3D pmu_events_table__find(); + +#define RETURN_IF_NON_ZERO(x) do { if (x) return x; } while (0) + hashmap__for_each_entry(ctx->ids, cur, bkt) { + const char *id =3D cur->pkey; + + pr_debug("found event %s\n", id); + + ret =3D get_metricgroup_events(id, etable, &event_info_list); + if (ret) + return ret; + } =20 - pr_debug("This is a placeholder\n"); return ret; +#undef RETURN_IF_NON_ZERO } =20 static void group_str_free(struct metricgroup__group_strs *g) @@ -1521,8 +1713,6 @@ static int hw_aware_parse_ids(struct perf_pmu *fake_p= mu, *out_evlist =3D parsed_evlist; parsed_evlist =3D NULL; err_out: - parse_events_error__exit(&parse_error); - evlist__delete(parsed_evlist); metricgroup__free_grouping_strs(&groupings); return ret; } diff --git a/tools/perf/util/metricgroup.h b/tools/perf/util/metricgroup.h index 89809df85..3704545c9 100644 --- a/tools/perf/util/metricgroup.h +++ b/tools/perf/util/metricgroup.h @@ -5,6 +5,7 @@ #include #include #include +#include #include "pmu-events/pmu-events.h" #include "strbuf.h" =20 @@ -67,6 +68,32 @@ struct metric_expr { int runtime; }; =20 +/* Maximum number of counters per PMU*/ +#define NR_COUNTERS 16 +/* + * Transfer bit position in the bitmap to ensure start assigning counter f= rom + * the last GP counter to the first. + * bit15 <---> bit0 + * [GP8-GP15] [GP0-GP7] + */ +#define TRANSFER_FIRST_BYTE(pos) (7 - pos) +#define TRANSFER_SEC_BYTE(pos) (23 - pos) + +/** + * An event used in a metric. This info is for metric grouping. + */ +struct metricgroup__event_info { + struct list_head nd; + /** The name of the event. */ + const char *name; + /** The name of the pmu the event be collected on. */ + const char *pmu_name; + bool fixed_counter; + bool free_counter; + /** The counters the event allowed to be collected on. */ + DECLARE_BITMAP(counters, NR_COUNTERS); +}; + /** * Each group is one node in the group string list. */ --=20 2.39.3