Commit 41f1138e authored by Leo Yan's avatar Leo Yan Committed by Arnaldo Carvalho de Melo
Browse files

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: default avatarLeo 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: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent ebf39d29

tools/perf/builtin-kvm.c

+228 −4
Original line number Diff line number Diff line
@@ -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)

tools/perf/util/kvm-stat.h

+2 −0
Original line number Diff line number Diff line
@@ -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);