@@ -24,6 +24,7 @@
#include <linux/list_sort.h>
#include <linux/string.h>
#include <linux/zalloc.h>
+#include <linux/bitmap.h>
#include <perf/cpumap.h>
#include <subcmd/parse-options.h>
#include <api/fs/fs.h>
@@ -157,6 +158,27 @@ struct metric {
struct evlist *evlist;
};
+/* Maximum number of counters per PMU*/
+#define NR_COUNTERS 16
+
+/**
+ * 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;
+ /** The event uses fixed counter*/
+ bool fixed_counter;
+ /** The event uses special counters that we consider that as free counter
+ * during the event grouping*/
+ 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.
*/
@@ -1440,6 +1462,175 @@ static int build_combined_expr_ctx(const struct list_head *metric_list,
return ret;
}
+/**
+ * set_counter_bitmap - The counter bitmap: [0-15].
+ */
+static int set_counter_bitmap(int pos, unsigned long *bitmap)
+{
+ if (pos >= NR_COUNTERS || pos < 0)
+ return -EINVAL;
+ __set_bit(pos, bitmap);
+ return 0;
+}
+
+static int parse_fixed_counter(const char *counter,
+ unsigned long *bitmap,
+ bool *fixed)
+{
+ int ret = -ENOENT;
+ //TODO: this pattern is different on some other platforms
+ const char *pattern = "Fixed counter ";
+ int pos = 0;
+
+ if (!strncmp(counter, pattern, strlen(pattern))) {
+ pos = atoi(counter + strlen(pattern));
+ ret = set_counter_bitmap(pos, bitmap);
+ if (ret)
+ return ret;
+ *fixed = true;
+ return 0;
+ }
+ return ret;
+}
+
+/**
+ * parse_counter - Parse event counter info from pmu-events and set up bitmap
+ * 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 = 0;
+ char *p;
+ char *tok;
+ int pos = 0;
+
+ ret = parse_fixed_counter(counter, bitmap, fixed);
+ // ret==0 means matched with fixed counter
+ if (ret == 0)
+ return ret;
+
+ p = strdup(counter);
+ tok = strtok(p, ",");
+ if (!tok)
+ return -ENOENT;
+
+ while (tok) {
+ pos = atoi(tok);
+ ret = set_counter_bitmap(pos, bitmap);
+ if (ret)
+ return ret;
+ tok = 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 = 0;
+ char *bit_buf = malloc(NR_COUNTERS);
+ bool fixed_counter = false;
+ struct metricgroup__event_info *e;
+
+ e = zalloc(sizeof(*e));
+ if (!e)
+ return NULL;
+ if (!pmu_name)
+ pmu_name = "core";
+
+ e->name = name;
+ e->free_counter = free_counter;
+ e->pmu_name = strdup(pmu_name);
+ if (free_counter) {
+ ret = set_counter_bitmap(0, e->counters);
+ if (ret)
+ return NULL;
+ } else {
+ ret = parse_counter(counter, e->counters, &fixed_counter);
+ if (ret)
+ return NULL;
+ e->fixed_counter = fixed_counter;
+ }
+
+ bitmap_scnprintf(e->counters, NR_COUNTERS, bit_buf, NR_COUNTERS);
+ pr_debug("Event %s requires pmu %s counter: %s bitmap %s, [pmu=%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 = data;
+
+ if (!strcasecmp(pe->name, d->event_name)) {
+ event = event_info__new(d->event_id, pe->pmu, pe->counter, /*free_counter=*/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 = 0;
+ const char *id;
+ const char *rsep, *sep = strchr(full_id, '@');
+
+ if (sep) {
+ rsep = strchr(full_id, ',');
+ id = strndup(sep + 1, rsep - sep - 1);
+ if (ret)
+ goto out;
+ } else {
+ id = full_id;
+ }
+ {
+ struct metricgroup__add_metric_event_data data = {
+ .list = &list,
+ .event_name = id,
+ .event_id = full_id,
+ };
+ ret = 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
@@ -1453,9 +1644,25 @@ static int hw_aware_build_grouping(struct expr_parse_ctx *ctx __maybe_unused,
const char *modifier __maybe_unused)
{
int ret = 0;
+ struct hashmap_entry *cur;
+ LIST_HEAD(pmu_info_list);
+ LIST_HEAD(event_info_list);
+ size_t bkt;
+ const struct pmu_events_table *etable = perf_pmu__find_events_table(NULL);
+
+#define RETURN_IF_NON_ZERO(x) do { if (x) return x; } while (0)
+ hashmap__for_each_entry(ctx->ids, cur, bkt) {
+ const char *id = cur->pkey;
+
+ pr_debug("found event %s\n", id);
+
+ ret = get_metricgroup_events(id, etable, &event_info_list);
+ if (ret)
+ return ret;
+ }
- pr_debug("This is a placeholder\n");
return ret;
+#undef RETURN_IF_NON_ZERO
}
static void group_str_free(struct metricgroup__group_strs *g)
@@ -1529,8 +1736,6 @@ static int hw_aware_parse_ids(struct perf_pmu *fake_pmu,
*out_evlist = parsed_evlist;
parsed_evlist = NULL;
err_out:
- parse_events_error__exit(&parse_error);
- evlist__delete(parsed_evlist);
metricgroup__free_grouping_strs(&groupings);
return ret;
}