perf kvm: Add dimensions for KVM event statistics

To support KVM event statistics, this patch firstly registers histograms
columns and sorting fields; every column or field has its own format
structure, the format structure is dereferenced to access the dimension,
finally the dimension provides the comparison callback for sorting
result.

Signed-off-by: Leo Yan <leo.yan@linaro.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@arm.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: John Garry <john.g.garry@oracle.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: linux-arm-kernel@lists.infradead.org
Link: https://lore.kernel.org/r/20230315145112.186603-2-leo.yan@linaro.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 17a8219a702a0e07fdb02b76a304186b6dc21ce5..899e331cf7273e845661aa8138bd7f866a0c2243 100644 (file)
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -71,9 +71,9 @@ static int64_t cmp_event_ ## func(struct kvm_event *one,              \
               get_event_ ##func(two, vcpu);                            \
 }
 
-GET_EVENT_KEY(time, time);
-GET_EVENT_KEY(max, stats.max);
-GET_EVENT_KEY(min, stats.min);
+COMPARE_EVENT_KEY(time, time);
+COMPARE_EVENT_KEY(max, stats.max);
+COMPARE_EVENT_KEY(min, stats.min);
 COMPARE_EVENT_KEY(count, stats.n);
 COMPARE_EVENT_KEY(mean, stats.mean);
 
@@ -91,13 +91,237 @@ struct kvm_hists {
        struct perf_hpp_list    list;
 };
 
+struct kvm_dimension {
+       const char *name;
+       int64_t (*cmp)(struct perf_hpp_fmt *fmt, struct hist_entry *left,
+                      struct hist_entry *right);
+};
+
+struct kvm_fmt {
+       struct perf_hpp_fmt     fmt;
+       struct kvm_dimension    *dim;
+};
+
 static struct kvm_hists kvm_hists;
 
+static int64_t ev_name_cmp(struct perf_hpp_fmt *fmt __maybe_unused,
+                          struct hist_entry *left,
+                          struct hist_entry *right)
+{
+       /* Return opposite number for sorting in alphabetical order */
+       return -strcmp(left->kvm_info->name, right->kvm_info->name);
+}
+
+static struct kvm_dimension dim_event = {
+       .name           = "ev_name",
+       .cmp            = ev_name_cmp,
+};
+
+#define EV_METRIC_CMP(metric)                                          \
+static int64_t ev_cmp_##metric(struct perf_hpp_fmt *fmt __maybe_unused,        \
+                              struct hist_entry *left,                 \
+                              struct hist_entry *right)                \
+{                                                                      \
+       struct kvm_event *event_left;                                   \
+       struct kvm_event *event_right;                                  \
+       struct perf_kvm_stat *perf_kvm;                                 \
+                                                                       \
+       event_left  = container_of(left, struct kvm_event, he);         \
+       event_right = container_of(right, struct kvm_event, he);        \
+                                                                       \
+       perf_kvm = event_left->perf_kvm;                                \
+       return cmp_event_##metric(event_left, event_right,              \
+                                 perf_kvm->trace_vcpu);                \
+}
+
+EV_METRIC_CMP(time)
+EV_METRIC_CMP(count)
+EV_METRIC_CMP(max)
+EV_METRIC_CMP(min)
+EV_METRIC_CMP(mean)
+
+static struct kvm_dimension dim_time = {
+       .name           = "time",
+       .cmp            = ev_cmp_time,
+};
+
+static struct kvm_dimension dim_count = {
+       .name           = "sample",
+       .cmp            = ev_cmp_count,
+};
+
+static struct kvm_dimension dim_max_time = {
+       .name           = "max_t",
+       .cmp            = ev_cmp_max,
+};
+
+static struct kvm_dimension dim_min_time = {
+       .name           = "min_t",
+       .cmp            = ev_cmp_min,
+};
+
+static struct kvm_dimension dim_mean_time = {
+       .name           = "mean_t",
+       .cmp            = ev_cmp_mean,
+};
+
+static struct kvm_dimension *dimensions[] = {
+       &dim_event,
+       &dim_time,
+       &dim_count,
+       &dim_max_time,
+       &dim_min_time,
+       &dim_mean_time,
+       NULL,
+};
+
+static bool fmt_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
+{
+       struct kvm_fmt *kvm_fmt_a = container_of(a, struct kvm_fmt, fmt);
+       struct kvm_fmt *kvm_fmt_b = container_of(b, struct kvm_fmt, fmt);
+
+       return kvm_fmt_a->dim == kvm_fmt_b->dim;
+}
+
+static void fmt_free(struct perf_hpp_fmt *fmt)
+{
+       struct kvm_fmt *kvm_fmt;
+
+       kvm_fmt = container_of(fmt, struct kvm_fmt, fmt);
+       free(kvm_fmt);
+}
+
+static struct kvm_dimension *get_dimension(const char *name)
+{
+       unsigned int i;
+
+       for (i = 0; dimensions[i] != NULL; i++) {
+               if (!strcmp(dimensions[i]->name, name))
+                       return dimensions[i];
+       }
+
+       return NULL;
+}
+
+static struct kvm_fmt *get_format(const char *name)
+{
+       struct kvm_dimension *dim = get_dimension(name);
+       struct kvm_fmt *kvm_fmt;
+       struct perf_hpp_fmt *fmt;
+
+       if (!dim)
+               return NULL;
+
+       kvm_fmt = zalloc(sizeof(*kvm_fmt));
+       if (!kvm_fmt)
+               return NULL;
+
+       kvm_fmt->dim = dim;
+
+       fmt = &kvm_fmt->fmt;
+       INIT_LIST_HEAD(&fmt->list);
+       INIT_LIST_HEAD(&fmt->sort_list);
+       fmt->cmp        = dim->cmp;
+       fmt->sort       = dim->cmp;
+       fmt->color      = NULL;
+       fmt->entry      = NULL;
+       fmt->header     = NULL;
+       fmt->width      = NULL;
+       fmt->collapse   = dim->cmp;
+       fmt->equal      = fmt_equal;
+       fmt->free       = fmt_free;
+
+       return kvm_fmt;
+}
+
+static int kvm_hists__init_output(struct perf_hpp_list *hpp_list, char *name)
+{
+       struct kvm_fmt *kvm_fmt = get_format(name);
+
+       if (!kvm_fmt) {
+               pr_warning("Fail to find format for output field %s.\n", name);
+               return -EINVAL;
+       }
+
+       perf_hpp_list__column_register(hpp_list, &kvm_fmt->fmt);
+       return 0;
+}
+
+static int kvm_hists__init_sort(struct perf_hpp_list *hpp_list, char *name)
+{
+       struct kvm_fmt *kvm_fmt = get_format(name);
+
+       if (!kvm_fmt) {
+               pr_warning("Fail to find format for sorting %s.\n", name);
+               return -EINVAL;
+       }
+
+       perf_hpp_list__register_sort_field(hpp_list, &kvm_fmt->fmt);
+       return 0;
+}
+
+static int kvm_hpp_list__init(char *list,
+                             struct perf_hpp_list *hpp_list,
+                             int (*fn)(struct perf_hpp_list *hpp_list,
+                                       char *name))
+{
+       char *tmp, *tok;
+       int ret;
+
+       if (!list || !fn)
+               return 0;
+
+       for (tok = strtok_r(list, ", ", &tmp); tok;
+            tok = strtok_r(NULL, ", ", &tmp)) {
+               ret = fn(hpp_list, tok);
+               if (!ret)
+                       continue;
+
+               /* Handle errors */
+               if (ret == -EINVAL)
+                       pr_err("Invalid field key: '%s'", tok);
+               else if (ret == -ESRCH)
+                       pr_err("Unknown field key: '%s'", tok);
+               else
+                       pr_err("Fail to initialize for field key: '%s'", tok);
+
+               break;
+       }
+
+       return ret;
+}
+
+static int kvm_hpp_list__parse(struct perf_hpp_list *hpp_list,
+                              const char *output_, const char *sort_)
+{
+       char *output = output_ ? strdup(output_) : NULL;
+       char *sort = sort_ ? strdup(sort_) : NULL;
+       int ret;
+
+       ret = kvm_hpp_list__init(output, hpp_list, kvm_hists__init_output);
+       if (ret)
+               goto out;
+
+       ret = kvm_hpp_list__init(sort, hpp_list, kvm_hists__init_sort);
+       if (ret)
+               goto out;
+
+       /* Copy sort keys to output fields */
+       perf_hpp__setup_output_field(hpp_list);
+
+       /* and then copy output fields to sort keys */
+       perf_hpp__append_sort_keys(hpp_list);
+out:
+       free(output);
+       free(sort);
+       return ret;
+}
+
 static int kvm_hists__init(void)
 {
        __hists__init(&kvm_hists.hists, &kvm_hists.list);
        perf_hpp_list__init(&kvm_hists.list);
-       return 0;
+       return kvm_hpp_list__parse(&kvm_hists.list, NULL, "ev_name");
 }
 #endif // defined(HAVE_KVM_STAT_SUPPORT) && defined(HAVE_LIBTRACEEVENT)
 

diff --git a/tools/perf/util/kvm-stat.h b/tools/perf/util/kvm-stat.h
index 0cf704333c4ce5a134ca7358ea0fdd799aa73289..fc30a72dfac1c038c89c9d363e5852f094ee14fb 100644 (file)
--- a/tools/perf/util/kvm-stat.h
+++ b/tools/perf/util/kvm-stat.h
@@ -46,6 +46,8 @@ struct kvm_event {
        #define DEFAULT_VCPU_NUM 8
        int max_vcpu;
        struct kvm_event_stats *vcpu;
+
+       struct hist_entry he;
 };
 
 typedef int64_t (*key_cmp_fun)(struct kvm_event*, struct kvm_event*, int);