[deliverable/linux.git] / tools / perf / ui / hist.c

#include <math.h>
#include <linux/compiler.h>

#include "../util/hist.h"
#include "../util/util.h"
#include "../util/sort.h"
#include "../util/evsel.h"

/* hist period print (hpp) functions */

#define hpp__call_print_fn(hpp, fn, fmt, ...)			\
({								\
	int __ret = fn(hpp, fmt, ##__VA_ARGS__);		\
	advance_hpp(hpp, __ret);				\
	__ret;							\
})

static int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
		      hpp_field_fn get_field, const char *fmt, int len,
		      hpp_snprint_fn print_fn, bool fmt_percent)
{
	int ret;
	struct hists *hists = he->hists;
	struct perf_evsel *evsel = hists_to_evsel(hists);
	char *buf = hpp->buf;
	size_t size = hpp->size;

	if (fmt_percent) {
		double percent = 0.0;
		u64 total = hists__total_period(hists);

		if (total)
			percent = 100.0 * get_field(he) / total;

		ret = hpp__call_print_fn(hpp, print_fn, fmt, len, percent);
	} else
		ret = hpp__call_print_fn(hpp, print_fn, fmt, len, get_field(he));

	if (perf_evsel__is_group_event(evsel)) {
		int prev_idx, idx_delta;
		struct hist_entry *pair;
		int nr_members = evsel->nr_members;

		prev_idx = perf_evsel__group_idx(evsel);

		list_for_each_entry(pair, &he->pairs.head, pairs.node) {
			u64 period = get_field(pair);
			u64 total = hists__total_period(pair->hists);

			if (!total)
				continue;

			evsel = hists_to_evsel(pair->hists);
			idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;

			while (idx_delta--) {
				/*
				 * zero-fill group members in the middle which
				 * have no sample
				 */
				if (fmt_percent) {
					ret += hpp__call_print_fn(hpp, print_fn,
								  fmt, len, 0.0);
				} else {
					ret += hpp__call_print_fn(hpp, print_fn,
								  fmt, len, 0ULL);
				}
			}

			if (fmt_percent) {
				ret += hpp__call_print_fn(hpp, print_fn, fmt, len,
							  100.0 * period / total);
			} else {
				ret += hpp__call_print_fn(hpp, print_fn, fmt,
							  len, period);
			}

			prev_idx = perf_evsel__group_idx(evsel);
		}

		idx_delta = nr_members - prev_idx - 1;

		while (idx_delta--) {
			/*
			 * zero-fill group members at last which have no sample
			 */
			if (fmt_percent) {
				ret += hpp__call_print_fn(hpp, print_fn,
							  fmt, len, 0.0);
			} else {
				ret += hpp__call_print_fn(hpp, print_fn,
							  fmt, len, 0ULL);
			}
		}
	}

	/*
	 * Restore original buf and size as it's where caller expects
	 * the result will be saved.
	 */
	hpp->buf = buf;
	hpp->size = size;

	return ret;
}

int hpp__fmt(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
	     struct hist_entry *he, hpp_field_fn get_field,
	     const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent)
{
	int len = fmt->user_len ?: fmt->len;

	if (symbol_conf.field_sep) {
		return __hpp__fmt(hpp, he, get_field, fmtstr, 1,
				  print_fn, fmt_percent);
	}

	if (fmt_percent)
		len -= 2; /* 2 for a space and a % sign */
	else
		len -= 1;

	return  __hpp__fmt(hpp, he, get_field, fmtstr, len, print_fn, fmt_percent);
}

int hpp__fmt_acc(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
		 struct hist_entry *he, hpp_field_fn get_field,
		 const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent)
{
	if (!symbol_conf.cumulate_callchain) {
		int len = fmt->user_len ?: fmt->len;
		return snprintf(hpp->buf, hpp->size, " %*s", len - 1, "N/A");
	}

	return hpp__fmt(fmt, hpp, he, get_field, fmtstr, print_fn, fmt_percent);
}

static int field_cmp(u64 field_a, u64 field_b)
{
	if (field_a > field_b)
		return 1;
	if (field_a < field_b)
		return -1;
	return 0;
}

static int __hpp__sort(struct hist_entry *a, struct hist_entry *b,
		       hpp_field_fn get_field)
{
	s64 ret;
	int i, nr_members;
	struct perf_evsel *evsel;
	struct hist_entry *pair;
	u64 *fields_a, *fields_b;

	ret = field_cmp(get_field(a), get_field(b));
	if (ret || !symbol_conf.event_group)
		return ret;

	evsel = hists_to_evsel(a->hists);
	if (!perf_evsel__is_group_event(evsel))
		return ret;

	nr_members = evsel->nr_members;
	fields_a = calloc(nr_members, sizeof(*fields_a));
	fields_b = calloc(nr_members, sizeof(*fields_b));

	if (!fields_a || !fields_b)
		goto out;

	list_for_each_entry(pair, &a->pairs.head, pairs.node) {
		evsel = hists_to_evsel(pair->hists);
		fields_a[perf_evsel__group_idx(evsel)] = get_field(pair);
	}

	list_for_each_entry(pair, &b->pairs.head, pairs.node) {
		evsel = hists_to_evsel(pair->hists);
		fields_b[perf_evsel__group_idx(evsel)] = get_field(pair);
	}

	for (i = 1; i < nr_members; i++) {
		ret = field_cmp(fields_a[i], fields_b[i]);
		if (ret)
			break;
	}

out:
	free(fields_a);
	free(fields_b);

	return ret;
}

static int __hpp__sort_acc(struct hist_entry *a, struct hist_entry *b,
			   hpp_field_fn get_field)
{
	s64 ret = 0;

	if (symbol_conf.cumulate_callchain) {
		/*
		 * Put caller above callee when they have equal period.
		 */
		ret = field_cmp(get_field(a), get_field(b));
		if (ret)
			return ret;

		if (a->thread != b->thread || !symbol_conf.use_callchain)
			return 0;

		ret = b->callchain->max_depth - a->callchain->max_depth;
	}
	return ret;
}

static int hpp__width_fn(struct perf_hpp_fmt *fmt,
			 struct perf_hpp *hpp __maybe_unused,
			 struct perf_evsel *evsel)
{
	int len = fmt->user_len ?: fmt->len;

	if (symbol_conf.event_group)
		len = max(len, evsel->nr_members * fmt->len);

	if (len < (int)strlen(fmt->name))
		len = strlen(fmt->name);

	return len;
}

static int hpp__header_fn(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
			  struct perf_evsel *evsel)
{
	int len = hpp__width_fn(fmt, hpp, evsel);
	return scnprintf(hpp->buf, hpp->size, "%*s", len, fmt->name);
}

static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
{
	va_list args;
	ssize_t ssize = hpp->size;
	double percent;
	int ret, len;

	va_start(args, fmt);
	len = va_arg(args, int);
	percent = va_arg(args, double);
	ret = percent_color_len_snprintf(hpp->buf, hpp->size, fmt, len, percent);
	va_end(args);

	return (ret >= ssize) ? (ssize - 1) : ret;
}

static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
{
	va_list args;
	ssize_t ssize = hpp->size;
	int ret;

	va_start(args, fmt);
	ret = vsnprintf(hpp->buf, hpp->size, fmt, args);
	va_end(args);

	return (ret >= ssize) ? (ssize - 1) : ret;
}

#define __HPP_COLOR_PERCENT_FN(_type, _field)					\
static u64 he_get_##_field(struct hist_entry *he)				\
{										\
	return he->stat._field;							\
}										\
										\
static int hpp__color_##_type(struct perf_hpp_fmt *fmt,				\
			      struct perf_hpp *hpp, struct hist_entry *he) 	\
{										\
	return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%",		\
			hpp_color_scnprintf, true);				\
}

#define __HPP_ENTRY_PERCENT_FN(_type, _field)					\
static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,				\
			      struct perf_hpp *hpp, struct hist_entry *he) 	\
{										\
	return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%",		\
			hpp_entry_scnprintf, true);				\
}

#define __HPP_SORT_FN(_type, _field)						\
static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b)	\
{										\
	return __hpp__sort(a, b, he_get_##_field);				\
}

#define __HPP_COLOR_ACC_PERCENT_FN(_type, _field)				\
static u64 he_get_acc_##_field(struct hist_entry *he)				\
{										\
	return he->stat_acc->_field;						\
}										\
										\
static int hpp__color_##_type(struct perf_hpp_fmt *fmt,				\
			      struct perf_hpp *hpp, struct hist_entry *he) 	\
{										\
	return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%", 	\
			    hpp_color_scnprintf, true);				\
}

#define __HPP_ENTRY_ACC_PERCENT_FN(_type, _field)				\
static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,				\
			      struct perf_hpp *hpp, struct hist_entry *he) 	\
{										\
	return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%",	\
			    hpp_entry_scnprintf, true);				\
}

#define __HPP_SORT_ACC_FN(_type, _field)					\
static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b)	\
{										\
	return __hpp__sort_acc(a, b, he_get_acc_##_field);			\
}

#define __HPP_ENTRY_RAW_FN(_type, _field)					\
static u64 he_get_raw_##_field(struct hist_entry *he)				\
{										\
	return he->stat._field;							\
}										\
										\
static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,				\
			      struct perf_hpp *hpp, struct hist_entry *he) 	\
{										\
	return hpp__fmt(fmt, hpp, he, he_get_raw_##_field, " %*"PRIu64, 	\
			hpp_entry_scnprintf, false);				\
}

#define __HPP_SORT_RAW_FN(_type, _field)					\
static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b)	\
{										\
	return __hpp__sort(a, b, he_get_raw_##_field);				\
}


#define HPP_PERCENT_FNS(_type, _field)					\
__HPP_COLOR_PERCENT_FN(_type, _field)					\
__HPP_ENTRY_PERCENT_FN(_type, _field)					\
__HPP_SORT_FN(_type, _field)

#define HPP_PERCENT_ACC_FNS(_type, _field)				\
__HPP_COLOR_ACC_PERCENT_FN(_type, _field)				\
__HPP_ENTRY_ACC_PERCENT_FN(_type, _field)				\
__HPP_SORT_ACC_FN(_type, _field)

#define HPP_RAW_FNS(_type, _field)					\
__HPP_ENTRY_RAW_FN(_type, _field)					\
__HPP_SORT_RAW_FN(_type, _field)

HPP_PERCENT_FNS(overhead, period)
HPP_PERCENT_FNS(overhead_sys, period_sys)
HPP_PERCENT_FNS(overhead_us, period_us)
HPP_PERCENT_FNS(overhead_guest_sys, period_guest_sys)
HPP_PERCENT_FNS(overhead_guest_us, period_guest_us)
HPP_PERCENT_ACC_FNS(overhead_acc, period)

HPP_RAW_FNS(samples, nr_events)
HPP_RAW_FNS(period, period)

static int64_t hpp__nop_cmp(struct hist_entry *a __maybe_unused,
			    struct hist_entry *b __maybe_unused)
{
	return 0;
}

#define HPP__COLOR_PRINT_FNS(_name, _fn)		\
	{						\
		.name   = _name,			\
		.header	= hpp__header_fn,		\
		.width	= hpp__width_fn,		\
		.color	= hpp__color_ ## _fn,		\
		.entry	= hpp__entry_ ## _fn,		\
		.cmp	= hpp__nop_cmp,			\
		.collapse = hpp__nop_cmp,		\
		.sort	= hpp__sort_ ## _fn,		\
	}

#define HPP__COLOR_ACC_PRINT_FNS(_name, _fn)		\
	{						\
		.name   = _name,			\
		.header	= hpp__header_fn,		\
		.width	= hpp__width_fn,		\
		.color	= hpp__color_ ## _fn,		\
		.entry	= hpp__entry_ ## _fn,		\
		.cmp	= hpp__nop_cmp,			\
		.collapse = hpp__nop_cmp,		\
		.sort	= hpp__sort_ ## _fn,		\
	}

#define HPP__PRINT_FNS(_name, _fn)			\
	{						\
		.name   = _name,			\
		.header	= hpp__header_fn,		\
		.width	= hpp__width_fn,		\
		.entry	= hpp__entry_ ## _fn,		\
		.cmp	= hpp__nop_cmp,			\
		.collapse = hpp__nop_cmp,		\
		.sort	= hpp__sort_ ## _fn,		\
	}

struct perf_hpp_fmt perf_hpp__format[] = {
	HPP__COLOR_PRINT_FNS("Overhead", overhead),
	HPP__COLOR_PRINT_FNS("sys", overhead_sys),
	HPP__COLOR_PRINT_FNS("usr", overhead_us),
	HPP__COLOR_PRINT_FNS("guest sys", overhead_guest_sys),
	HPP__COLOR_PRINT_FNS("guest usr", overhead_guest_us),
	HPP__COLOR_ACC_PRINT_FNS("Children", overhead_acc),
	HPP__PRINT_FNS("Samples", samples),
	HPP__PRINT_FNS("Period", period)
};

LIST_HEAD(perf_hpp__list);
LIST_HEAD(perf_hpp__sort_list);


#undef HPP__COLOR_PRINT_FNS
#undef HPP__COLOR_ACC_PRINT_FNS
#undef HPP__PRINT_FNS

#undef HPP_PERCENT_FNS
#undef HPP_PERCENT_ACC_FNS
#undef HPP_RAW_FNS

#undef __HPP_HEADER_FN
#undef __HPP_WIDTH_FN
#undef __HPP_COLOR_PERCENT_FN
#undef __HPP_ENTRY_PERCENT_FN
#undef __HPP_COLOR_ACC_PERCENT_FN
#undef __HPP_ENTRY_ACC_PERCENT_FN
#undef __HPP_ENTRY_RAW_FN
#undef __HPP_SORT_FN
#undef __HPP_SORT_ACC_FN
#undef __HPP_SORT_RAW_FN


void perf_hpp__init(void)
{
	struct list_head *list;
	int i;

	for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
		struct perf_hpp_fmt *fmt = &perf_hpp__format[i];

		INIT_LIST_HEAD(&fmt->list);

		/* sort_list may be linked by setup_sorting() */
		if (fmt->sort_list.next == NULL)
			INIT_LIST_HEAD(&fmt->sort_list);
	}

	/*
	 * If user specified field order, no need to setup default fields.
	 */
	if (is_strict_order(field_order))
		return;

	if (symbol_conf.cumulate_callchain) {
		perf_hpp__column_enable(PERF_HPP__OVERHEAD_ACC);
		perf_hpp__format[PERF_HPP__OVERHEAD].name = "Self";
	}

	perf_hpp__column_enable(PERF_HPP__OVERHEAD);

	if (symbol_conf.show_cpu_utilization) {
		perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
		perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);

		if (perf_guest) {
			perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS);
			perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US);
		}
	}

	if (symbol_conf.show_nr_samples)
		perf_hpp__column_enable(PERF_HPP__SAMPLES);

	if (symbol_conf.show_total_period)
		perf_hpp__column_enable(PERF_HPP__PERIOD);

	/* prepend overhead field for backward compatiblity.  */
	list = &perf_hpp__format[PERF_HPP__OVERHEAD].sort_list;
	if (list_empty(list))
		list_add(list, &perf_hpp__sort_list);

	if (symbol_conf.cumulate_callchain) {
		list = &perf_hpp__format[PERF_HPP__OVERHEAD_ACC].sort_list;
		if (list_empty(list))
			list_add(list, &perf_hpp__sort_list);
	}
}

void perf_hpp__column_register(struct perf_hpp_fmt *format)
{
	list_add_tail(&format->list, &perf_hpp__list);
}

void perf_hpp__column_unregister(struct perf_hpp_fmt *format)
{
	list_del(&format->list);
}

void perf_hpp__register_sort_field(struct perf_hpp_fmt *format)
{
	list_add_tail(&format->sort_list, &perf_hpp__sort_list);
}

void perf_hpp__column_enable(unsigned col)
{
	BUG_ON(col >= PERF_HPP__MAX_INDEX);
	perf_hpp__column_register(&perf_hpp__format[col]);
}

void perf_hpp__column_disable(unsigned col)
{
	BUG_ON(col >= PERF_HPP__MAX_INDEX);
	perf_hpp__column_unregister(&perf_hpp__format[col]);
}

void perf_hpp__cancel_cumulate(void)
{
	if (is_strict_order(field_order))
		return;

	perf_hpp__column_disable(PERF_HPP__OVERHEAD_ACC);
	perf_hpp__format[PERF_HPP__OVERHEAD].name = "Overhead";
}

void perf_hpp__setup_output_field(void)
{
	struct perf_hpp_fmt *fmt;

	/* append sort keys to output field */
	perf_hpp__for_each_sort_list(fmt) {
		if (!list_empty(&fmt->list))
			continue;

		/*
		 * sort entry fields are dynamically created,
		 * so they can share a same sort key even though
		 * the list is empty.
		 */
		if (perf_hpp__is_sort_entry(fmt)) {
			struct perf_hpp_fmt *pos;

			perf_hpp__for_each_format(pos) {
				if (perf_hpp__same_sort_entry(pos, fmt))
					goto next;
			}
		}

		perf_hpp__column_register(fmt);
next:
		continue;
	}
}

void perf_hpp__append_sort_keys(void)
{
	struct perf_hpp_fmt *fmt;

	/* append output fields to sort keys */
	perf_hpp__for_each_format(fmt) {
		if (!list_empty(&fmt->sort_list))
			continue;

		/*
		 * sort entry fields are dynamically created,
		 * so they can share a same sort key even though
		 * the list is empty.
		 */
		if (perf_hpp__is_sort_entry(fmt)) {
			struct perf_hpp_fmt *pos;

			perf_hpp__for_each_sort_list(pos) {
				if (perf_hpp__same_sort_entry(pos, fmt))
					goto next;
			}
		}

		perf_hpp__register_sort_field(fmt);
next:
		continue;
	}
}

void perf_hpp__reset_output_field(void)
{
	struct perf_hpp_fmt *fmt, *tmp;

	/* reset output fields */
	perf_hpp__for_each_format_safe(fmt, tmp) {
		list_del_init(&fmt->list);
		list_del_init(&fmt->sort_list);
	}

	/* reset sort keys */
	perf_hpp__for_each_sort_list_safe(fmt, tmp) {
		list_del_init(&fmt->list);
		list_del_init(&fmt->sort_list);
	}
}

/*
 * See hists__fprintf to match the column widths
 */
unsigned int hists__sort_list_width(struct hists *hists)
{
	struct perf_hpp_fmt *fmt;
	int ret = 0;
	bool first = true;
	struct perf_hpp dummy_hpp;

	perf_hpp__for_each_format(fmt) {
		if (perf_hpp__should_skip(fmt))
			continue;

		if (first)
			first = false;
		else
			ret += 2;

		ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
	}

	if (verbose && sort__has_sym) /* Addr + origin */
		ret += 3 + BITS_PER_LONG / 4;

	return ret;
}

void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists)
{
	int idx;

	if (perf_hpp__is_sort_entry(fmt))
		return perf_hpp__reset_sort_width(fmt, hists);

	for (idx = 0; idx < PERF_HPP__MAX_INDEX; idx++) {
		if (fmt == &perf_hpp__format[idx])
			break;
	}

	if (idx == PERF_HPP__MAX_INDEX)
		return;

	switch (idx) {
	case PERF_HPP__OVERHEAD:
	case PERF_HPP__OVERHEAD_SYS:
	case PERF_HPP__OVERHEAD_US:
	case PERF_HPP__OVERHEAD_ACC:
		fmt->len = 8;
		break;

	case PERF_HPP__OVERHEAD_GUEST_SYS:
	case PERF_HPP__OVERHEAD_GUEST_US:
		fmt->len = 9;
		break;

	case PERF_HPP__SAMPLES:
	case PERF_HPP__PERIOD:
		fmt->len = 12;
		break;

	default:
		break;
	}
}

void perf_hpp__set_user_width(const char *width_list_str)
{
	struct perf_hpp_fmt *fmt;
	const char *ptr = width_list_str;

	perf_hpp__for_each_format(fmt) {
		char *p;

		int len = strtol(ptr, &p, 10);
		fmt->user_len = len;

		if (*p == ',')
			ptr = p + 1;
		else
			break;
	}
}
Commit	Line	Data
ea251d51	1	#include <math.h>
2c5d4b4a	2	#include <linux/compiler.h>
ea251d51 NK	3
	4	#include "../util/hist.h"
	5	#include "../util/util.h"
	6	#include "../util/sort.h"
4fb71074	7	#include "../util/evsel.h"
ea251d51 NK	8
ea251d51 NK	9	/* hist period print (hpp) functions */
ea251d51	10
a0088adc NK	11	#define hpp__call_print_fn(hpp, fn, fmt, ...) \
	12	({ \
	13	int __ret = fn(hpp, fmt, ##__VA_ARGS__); \
	14	advance_hpp(hpp, __ret); \
	15	__ret; \
	16	})
	17
5b591669 NK	18	static int __hpp__fmt(struct perf_hpp hpp, struct hist_entry he,
	19	hpp_field_fn get_field, const char *fmt, int len,
	20	hpp_snprint_fn print_fn, bool fmt_percent)
ea251d51	21	{
fb821c9e	22	int ret;
b5ff71c3	23	struct hists *hists = he->hists;
759ff497	24	struct perf_evsel *evsel = hists_to_evsel(hists);
a0088adc NK	25	char *buf = hpp->buf;
a0088adc NK	26	size_t size = hpp->size;
ea251d51	27
0c5268bf JO	28	if (fmt_percent) {
0c5268bf JO	29	double percent = 0.0;
f2148330	30	u64 total = hists__total_period(hists);
9ffad987	31
f2148330 NK	32	if (total)
f2148330 NK	33	percent = 100.0 * get_field(he) / total;
0c5268bf	34
d675107c	35	ret = hpp__call_print_fn(hpp, print_fn, fmt, len, percent);
0c5268bf	36	} else
d675107c	37	ret = hpp__call_print_fn(hpp, print_fn, fmt, len, get_field(he));
5b9e2146	38
759ff497	39	if (perf_evsel__is_group_event(evsel)) {
5b9e2146	40	int prev_idx, idx_delta;
5b9e2146 NK	41	struct hist_entry *pair;
	42	int nr_members = evsel->nr_members;
	43
5b9e2146 NK	44	prev_idx = perf_evsel__group_idx(evsel);
	45
	46	list_for_each_entry(pair, &he->pairs.head, pairs.node) {
	47	u64 period = get_field(pair);
f2148330	48	u64 total = hists__total_period(pair->hists);
5b9e2146 NK	49
	50	if (!total)
	51	continue;
	52
	53	evsel = hists_to_evsel(pair->hists);
	54	idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;
	55
	56	while (idx_delta--) {
	57	/*
	58	* zero-fill group members in the middle which
	59	* have no sample
	60	*/
9b0d2fb8	61	if (fmt_percent) {
a0088adc	62	ret += hpp__call_print_fn(hpp, print_fn,
d675107c	63	fmt, len, 0.0);
9b0d2fb8	64	} else {
a0088adc	65	ret += hpp__call_print_fn(hpp, print_fn,
d675107c	66	fmt, len, 0ULL);
9b0d2fb8	67	}
5b9e2146 NK	68	}
5b9e2146 NK	69
a0088adc	70	if (fmt_percent) {
d675107c	71	ret += hpp__call_print_fn(hpp, print_fn, fmt, len,
a0088adc NK	72	100.0 * period / total);
	73	} else {
	74	ret += hpp__call_print_fn(hpp, print_fn, fmt,
d675107c	75	len, period);
a0088adc	76	}
5b9e2146 NK	77
	78	prev_idx = perf_evsel__group_idx(evsel);
	79	}
	80
	81	idx_delta = nr_members - prev_idx - 1;
	82
	83	while (idx_delta--) {
	84	/*
	85	* zero-fill group members at last which have no sample
	86	*/
9b0d2fb8	87	if (fmt_percent) {
a0088adc	88	ret += hpp__call_print_fn(hpp, print_fn,
d675107c	89	fmt, len, 0.0);
9b0d2fb8	90	} else {
a0088adc	91	ret += hpp__call_print_fn(hpp, print_fn,
d675107c	92	fmt, len, 0ULL);
9b0d2fb8	93	}
5b9e2146 NK	94	}
5b9e2146 NK	95	}
a0088adc NK	96
	97	/*
	98	* Restore original buf and size as it's where caller expects
	99	* the result will be saved.
	100	*/
	101	hpp->buf = buf;
	102	hpp->size = size;
	103
4fb71074	104	return ret;
ea251d51 NK	105	}
ea251d51 NK	106
5b591669 NK	107	int hpp__fmt(struct perf_hpp_fmt fmt, struct perf_hpp hpp,
	108	struct hist_entry *he, hpp_field_fn get_field,
	109	const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent)
	110	{
	111	int len = fmt->user_len ?: fmt->len;
	112
	113	if (symbol_conf.field_sep) {
	114	return __hpp__fmt(hpp, he, get_field, fmtstr, 1,
	115	print_fn, fmt_percent);
	116	}
	117
	118	if (fmt_percent)
	119	len -= 2; /* 2 for a space and a % sign */
	120	else
	121	len -= 1;
	122
	123	return __hpp__fmt(hpp, he, get_field, fmtstr, len, print_fn, fmt_percent);
	124	}
	125
	126	int hpp__fmt_acc(struct perf_hpp_fmt fmt, struct perf_hpp hpp,
	127	struct hist_entry *he, hpp_field_fn get_field,
	128	const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent)
594dcbf3 NK	129	{
594dcbf3 NK	130	if (!symbol_conf.cumulate_callchain) {
5b591669 NK	131	int len = fmt->user_len ?: fmt->len;
5b591669 NK	132	return snprintf(hpp->buf, hpp->size, " %*s", len - 1, "N/A");
594dcbf3 NK	133	}
594dcbf3 NK	134
5b591669	135	return hpp__fmt(fmt, hpp, he, get_field, fmtstr, print_fn, fmt_percent);
594dcbf3 NK	136	}
594dcbf3 NK	137
f156d84e NK	138	static int field_cmp(u64 field_a, u64 field_b)
	139	{
	140	if (field_a > field_b)
	141	return 1;
	142	if (field_a < field_b)
	143	return -1;
	144	return 0;
	145	}
	146
	147	static int __hpp__sort(struct hist_entry a, struct hist_entry b,
	148	hpp_field_fn get_field)
	149	{
	150	s64 ret;
	151	int i, nr_members;
	152	struct perf_evsel *evsel;
	153	struct hist_entry *pair;
	154	u64 fields_a, fields_b;
	155
	156	ret = field_cmp(get_field(a), get_field(b));
	157	if (ret \|\| !symbol_conf.event_group)
	158	return ret;
	159
	160	evsel = hists_to_evsel(a->hists);
	161	if (!perf_evsel__is_group_event(evsel))
	162	return ret;
	163
	164	nr_members = evsel->nr_members;
e4e458b4 AS	165	fields_a = calloc(nr_members, sizeof(*fields_a));
e4e458b4 AS	166	fields_b = calloc(nr_members, sizeof(*fields_b));
f156d84e NK	167
	168	if (!fields_a \|\| !fields_b)
	169	goto out;
	170
	171	list_for_each_entry(pair, &a->pairs.head, pairs.node) {
	172	evsel = hists_to_evsel(pair->hists);
	173	fields_a[perf_evsel__group_idx(evsel)] = get_field(pair);
	174	}
	175
	176	list_for_each_entry(pair, &b->pairs.head, pairs.node) {
	177	evsel = hists_to_evsel(pair->hists);
	178	fields_b[perf_evsel__group_idx(evsel)] = get_field(pair);
	179	}
	180
	181	for (i = 1; i < nr_members; i++) {
	182	ret = field_cmp(fields_a[i], fields_b[i]);
	183	if (ret)
	184	break;
	185	}
	186
	187	out:
	188	free(fields_a);
	189	free(fields_b);
	190
	191	return ret;
	192	}
	193
594dcbf3 NK	194	static int __hpp__sort_acc(struct hist_entry a, struct hist_entry b,
	195	hpp_field_fn get_field)
	196	{
	197	s64 ret = 0;
	198
	199	if (symbol_conf.cumulate_callchain) {
	200	/*
	201	* Put caller above callee when they have equal period.
	202	*/
	203	ret = field_cmp(get_field(a), get_field(b));
	204	if (ret)
	205	return ret;
	206
5ca82710 NK	207	if (a->thread != b->thread \|\| !symbol_conf.use_callchain)
	208	return 0;
	209
594dcbf3 NK	210	ret = b->callchain->max_depth - a->callchain->max_depth;
	211	}
	212	return ret;
	213	}
	214
1ecd4453 NK	215	static int hpp__width_fn(struct perf_hpp_fmt *fmt,
	216	struct perf_hpp *hpp __maybe_unused,
	217	struct perf_evsel *evsel)
	218	{
	219	int len = fmt->user_len ?: fmt->len;
	220
	221	if (symbol_conf.event_group)
	222	len = max(len, evsel->nr_members * fmt->len);
	223
	224	if (len < (int)strlen(fmt->name))
	225	len = strlen(fmt->name);
	226
	227	return len;
ea251d51 NK	228	}
ea251d51 NK	229
1ecd4453 NK	230	static int hpp__header_fn(struct perf_hpp_fmt fmt, struct perf_hpp hpp,
	231	struct perf_evsel *evsel)
	232	{
	233	int len = hpp__width_fn(fmt, hpp, evsel);
	234	return scnprintf(hpp->buf, hpp->size, "%*s", len, fmt->name);
e0d66c74 NK	235	}
e0d66c74 NK	236
a0088adc NK	237	static int hpp_color_scnprintf(struct perf_hpp hpp, const char fmt, ...)
	238	{
	239	va_list args;
	240	ssize_t ssize = hpp->size;
	241	double percent;
d675107c	242	int ret, len;
a0088adc NK	243
a0088adc NK	244	va_start(args, fmt);
d675107c	245	len = va_arg(args, int);
a0088adc	246	percent = va_arg(args, double);
d675107c	247	ret = percent_color_len_snprintf(hpp->buf, hpp->size, fmt, len, percent);
a0088adc NK	248	va_end(args);
	249
	250	return (ret >= ssize) ? (ssize - 1) : ret;
	251	}
	252
	253	static int hpp_entry_scnprintf(struct perf_hpp hpp, const char fmt, ...)
	254	{
	255	va_list args;
	256	ssize_t ssize = hpp->size;
	257	int ret;
	258
	259	va_start(args, fmt);
	260	ret = vsnprintf(hpp->buf, hpp->size, fmt, args);
	261	va_end(args);
	262
	263	return (ret >= ssize) ? (ssize - 1) : ret;
	264	}
	265
4fb71074 NK	266	#define __HPP_COLOR_PERCENT_FN(_type, _field) \
	267	static u64 he_get_##_field(struct hist_entry *he) \
	268	{ \
	269	return he->stat._field; \
	270	} \
	271	\
e0d66c74	272	static int hpp__color_##_type(struct perf_hpp_fmt *fmt, \
2c5d4b4a	273	struct perf_hpp hpp, struct hist_entry he) \
4fb71074	274	{ \
5b591669 NK	275	return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%", \
5b591669 NK	276	hpp_color_scnprintf, true); \
ea251d51 NK	277	}
ea251d51 NK	278
4fb71074	279	#define __HPP_ENTRY_PERCENT_FN(_type, _field) \
e0d66c74	280	static int hpp__entry_##_type(struct perf_hpp_fmt *fmt, \
2c5d4b4a	281	struct perf_hpp hpp, struct hist_entry he) \
4fb71074	282	{ \
5b591669 NK	283	return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%", \
5b591669 NK	284	hpp_entry_scnprintf, true); \
ea251d51 NK	285	}
ea251d51 NK	286
bc18b7f2 NK	287	#define __HPP_SORT_FN(_type, _field) \
	288	static int64_t hpp__sort_##_type(struct hist_entry a, struct hist_entry b) \
	289	{ \
f156d84e	290	return __hpp__sort(a, b, he_get_##_field); \
bc18b7f2 NK	291	}
bc18b7f2 NK	292
594dcbf3 NK	293	#define __HPP_COLOR_ACC_PERCENT_FN(_type, _field) \
	294	static u64 he_get_acc_##_field(struct hist_entry *he) \
	295	{ \
	296	return he->stat_acc->_field; \
	297	} \
	298	\
e0d66c74	299	static int hpp__color_##_type(struct perf_hpp_fmt *fmt, \
594dcbf3 NK	300	struct perf_hpp hpp, struct hist_entry he) \
594dcbf3 NK	301	{ \
5b591669 NK	302	return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%", \
5b591669 NK	303	hpp_color_scnprintf, true); \
594dcbf3 NK	304	}
	305
	306	#define __HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \
e0d66c74	307	static int hpp__entry_##_type(struct perf_hpp_fmt *fmt, \
594dcbf3 NK	308	struct perf_hpp hpp, struct hist_entry he) \
594dcbf3 NK	309	{ \
2bfa1528	310	return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%", \
5b591669	311	hpp_entry_scnprintf, true); \
594dcbf3 NK	312	}
	313
	314	#define __HPP_SORT_ACC_FN(_type, _field) \
	315	static int64_t hpp__sort_##_type(struct hist_entry a, struct hist_entry b) \
	316	{ \
	317	return __hpp__sort_acc(a, b, he_get_acc_##_field); \
	318	}
	319
4fb71074 NK	320	#define __HPP_ENTRY_RAW_FN(_type, _field) \
	321	static u64 he_get_raw_##_field(struct hist_entry *he) \
	322	{ \
	323	return he->stat._field; \
	324	} \
	325	\
e0d66c74	326	static int hpp__entry_##_type(struct perf_hpp_fmt *fmt, \
2c5d4b4a	327	struct perf_hpp hpp, struct hist_entry he) \
4fb71074	328	{ \
5b591669 NK	329	return hpp__fmt(fmt, hpp, he, he_get_raw_##_field, " %*"PRIu64, \
5b591669 NK	330	hpp_entry_scnprintf, false); \
ea251d51 NK	331	}
ea251d51 NK	332
bc18b7f2 NK	333	#define __HPP_SORT_RAW_FN(_type, _field) \
	334	static int64_t hpp__sort_##_type(struct hist_entry a, struct hist_entry b) \
	335	{ \
f156d84e	336	return __hpp__sort(a, b, he_get_raw_##_field); \
bc18b7f2 NK	337	}
	338
	339
1ecd4453	340	#define HPP_PERCENT_FNS(_type, _field) \
4fb71074	341	__HPP_COLOR_PERCENT_FN(_type, _field) \
bc18b7f2 NK	342	__HPP_ENTRY_PERCENT_FN(_type, _field) \
bc18b7f2 NK	343	__HPP_SORT_FN(_type, _field)
ea251d51	344
1ecd4453	345	#define HPP_PERCENT_ACC_FNS(_type, _field) \
594dcbf3 NK	346	__HPP_COLOR_ACC_PERCENT_FN(_type, _field) \
	347	__HPP_ENTRY_ACC_PERCENT_FN(_type, _field) \
	348	__HPP_SORT_ACC_FN(_type, _field)
	349
1ecd4453	350	#define HPP_RAW_FNS(_type, _field) \
bc18b7f2 NK	351	__HPP_ENTRY_RAW_FN(_type, _field) \
bc18b7f2 NK	352	__HPP_SORT_RAW_FN(_type, _field)
ea251d51	353
1ecd4453 NK	354	HPP_PERCENT_FNS(overhead, period)
	355	HPP_PERCENT_FNS(overhead_sys, period_sys)
	356	HPP_PERCENT_FNS(overhead_us, period_us)
	357	HPP_PERCENT_FNS(overhead_guest_sys, period_guest_sys)
	358	HPP_PERCENT_FNS(overhead_guest_us, period_guest_us)
	359	HPP_PERCENT_ACC_FNS(overhead_acc, period)
b5ff71c3	360
1ecd4453 NK	361	HPP_RAW_FNS(samples, nr_events)
1ecd4453 NK	362	HPP_RAW_FNS(period, period)
9ffad987	363
bc18b7f2 NK	364	static int64_t hpp__nop_cmp(struct hist_entry *a __maybe_unused,
	365	struct hist_entry *b __maybe_unused)
	366	{
	367	return 0;
	368	}
	369
1ecd4453	370	#define HPP__COLOR_PRINT_FNS(_name, _fn) \
1240005e	371	{ \
1ecd4453 NK	372	.name = _name, \
	373	.header = hpp__header_fn, \
	374	.width = hpp__width_fn, \
	375	.color = hpp__color_ ## _fn, \
	376	.entry = hpp__entry_ ## _fn, \
bc18b7f2 NK	377	.cmp = hpp__nop_cmp, \
bc18b7f2 NK	378	.collapse = hpp__nop_cmp, \
1ecd4453	379	.sort = hpp__sort_ ## _fn, \
1240005e	380	}
ea251d51	381
1ecd4453	382	#define HPP__COLOR_ACC_PRINT_FNS(_name, _fn) \
594dcbf3	383	{ \
1ecd4453 NK	384	.name = _name, \
	385	.header = hpp__header_fn, \
	386	.width = hpp__width_fn, \
	387	.color = hpp__color_ ## _fn, \
	388	.entry = hpp__entry_ ## _fn, \
594dcbf3 NK	389	.cmp = hpp__nop_cmp, \
594dcbf3 NK	390	.collapse = hpp__nop_cmp, \
1ecd4453	391	.sort = hpp__sort_ ## _fn, \
594dcbf3 NK	392	}
594dcbf3 NK	393
1ecd4453	394	#define HPP__PRINT_FNS(_name, _fn) \
1240005e	395	{ \
1ecd4453 NK	396	.name = _name, \
	397	.header = hpp__header_fn, \
	398	.width = hpp__width_fn, \
	399	.entry = hpp__entry_ ## _fn, \
bc18b7f2 NK	400	.cmp = hpp__nop_cmp, \
bc18b7f2 NK	401	.collapse = hpp__nop_cmp, \
1ecd4453	402	.sort = hpp__sort_ ## _fn, \
1240005e	403	}
ea251d51 NK	404
ea251d51 NK	405	struct perf_hpp_fmt perf_hpp__format[] = {
1ecd4453 NK	406	HPP__COLOR_PRINT_FNS("Overhead", overhead),
	407	HPP__COLOR_PRINT_FNS("sys", overhead_sys),
	408	HPP__COLOR_PRINT_FNS("usr", overhead_us),
	409	HPP__COLOR_PRINT_FNS("guest sys", overhead_guest_sys),
	410	HPP__COLOR_PRINT_FNS("guest usr", overhead_guest_us),
	411	HPP__COLOR_ACC_PRINT_FNS("Children", overhead_acc),
	412	HPP__PRINT_FNS("Samples", samples),
	413	HPP__PRINT_FNS("Period", period)
ea251d51 NK	414	};
ea251d51 NK	415
1240005e	416	LIST_HEAD(perf_hpp__list);
8b536999	417	LIST_HEAD(perf_hpp__sort_list);
1240005e	418
4fb71074	419
ea251d51	420	#undef HPP__COLOR_PRINT_FNS
594dcbf3	421	#undef HPP__COLOR_ACC_PRINT_FNS
ea251d51 NK	422	#undef HPP__PRINT_FNS
ea251d51 NK	423
4fb71074	424	#undef HPP_PERCENT_FNS
594dcbf3	425	#undef HPP_PERCENT_ACC_FNS
4fb71074 NK	426	#undef HPP_RAW_FNS
	427
	428	#undef __HPP_HEADER_FN
	429	#undef __HPP_WIDTH_FN
	430	#undef __HPP_COLOR_PERCENT_FN
	431	#undef __HPP_ENTRY_PERCENT_FN
594dcbf3 NK	432	#undef __HPP_COLOR_ACC_PERCENT_FN
594dcbf3 NK	433	#undef __HPP_ENTRY_ACC_PERCENT_FN
4fb71074	434	#undef __HPP_ENTRY_RAW_FN
594dcbf3 NK	435	#undef __HPP_SORT_FN
	436	#undef __HPP_SORT_ACC_FN
	437	#undef __HPP_SORT_RAW_FN
4fb71074 NK	438
4fb71074 NK	439
1d77822e	440	void perf_hpp__init(void)
ea251d51	441	{
26d8b338 NK	442	struct list_head *list;
	443	int i;
	444
	445	for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
a2ce067e NK	446	struct perf_hpp_fmt *fmt = &perf_hpp__format[i];
	447
	448	INIT_LIST_HEAD(&fmt->list);
	449
	450	/* sort_list may be linked by setup_sorting() */
	451	if (fmt->sort_list.next == NULL)
	452	INIT_LIST_HEAD(&fmt->sort_list);
26d8b338 NK	453	}
26d8b338 NK	454
a7d945bc NK	455	/*
	456	* If user specified field order, no need to setup default fields.
	457	*/
2f3f9bcf	458	if (is_strict_order(field_order))
a7d945bc NK	459	return;
a7d945bc NK	460
594dcbf3 NK	461	if (symbol_conf.cumulate_callchain) {
594dcbf3 NK	462	perf_hpp__column_enable(PERF_HPP__OVERHEAD_ACC);
1ecd4453	463	perf_hpp__format[PERF_HPP__OVERHEAD].name = "Self";
594dcbf3 NK	464	}
594dcbf3 NK	465
2b8bfa6b JO	466	perf_hpp__column_enable(PERF_HPP__OVERHEAD);
2b8bfa6b JO	467
ea251d51	468	if (symbol_conf.show_cpu_utilization) {
1240005e JO	469	perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS);
1240005e JO	470	perf_hpp__column_enable(PERF_HPP__OVERHEAD_US);
ea251d51 NK	471
ea251d51 NK	472	if (perf_guest) {
1240005e JO	473	perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS);
1240005e JO	474	perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US);
ea251d51 NK	475	}
	476	}
	477
	478	if (symbol_conf.show_nr_samples)
1240005e	479	perf_hpp__column_enable(PERF_HPP__SAMPLES);
ea251d51 NK	480
ea251d51 NK	481	if (symbol_conf.show_total_period)
1240005e	482	perf_hpp__column_enable(PERF_HPP__PERIOD);
26d8b338 NK	483
	484	/* prepend overhead field for backward compatiblity. */
	485	list = &perf_hpp__format[PERF_HPP__OVERHEAD].sort_list;
	486	if (list_empty(list))
	487	list_add(list, &perf_hpp__sort_list);
594dcbf3 NK	488
	489	if (symbol_conf.cumulate_callchain) {
	490	list = &perf_hpp__format[PERF_HPP__OVERHEAD_ACC].sort_list;
	491	if (list_empty(list))
	492	list_add(list, &perf_hpp__sort_list);
	493	}
1d77822e	494	}
ea251d51	495
1240005e JO	496	void perf_hpp__column_register(struct perf_hpp_fmt *format)
	497	{
	498	list_add_tail(&format->list, &perf_hpp__list);
	499	}
	500
77284de3 NK	501	void perf_hpp__column_unregister(struct perf_hpp_fmt *format)
	502	{
	503	list_del(&format->list);
	504	}
	505
8b536999 NK	506	void perf_hpp__register_sort_field(struct perf_hpp_fmt *format)
	507	{
	508	list_add_tail(&format->sort_list, &perf_hpp__sort_list);
	509	}
	510
1240005e	511	void perf_hpp__column_enable(unsigned col)
1d77822e JO	512	{
1d77822e JO	513	BUG_ON(col >= PERF_HPP__MAX_INDEX);
1240005e	514	perf_hpp__column_register(&perf_hpp__format[col]);
ea251d51 NK	515	}
ea251d51 NK	516
77284de3 NK	517	void perf_hpp__column_disable(unsigned col)
	518	{
	519	BUG_ON(col >= PERF_HPP__MAX_INDEX);
	520	perf_hpp__column_unregister(&perf_hpp__format[col]);
	521	}
	522
	523	void perf_hpp__cancel_cumulate(void)
	524	{
2f3f9bcf	525	if (is_strict_order(field_order))
2bf1a123 NK	526	return;
2bf1a123 NK	527
77284de3	528	perf_hpp__column_disable(PERF_HPP__OVERHEAD_ACC);
1ecd4453	529	perf_hpp__format[PERF_HPP__OVERHEAD].name = "Overhead";
77284de3 NK	530	}
77284de3 NK	531
26d8b338 NK	532	void perf_hpp__setup_output_field(void)
	533	{
	534	struct perf_hpp_fmt *fmt;
	535
	536	/* append sort keys to output field */
	537	perf_hpp__for_each_sort_list(fmt) {
a7d945bc NK	538	if (!list_empty(&fmt->list))
	539	continue;
	540
	541	/*
	542	* sort entry fields are dynamically created,
	543	* so they can share a same sort key even though
	544	* the list is empty.
	545	*/
	546	if (perf_hpp__is_sort_entry(fmt)) {
	547	struct perf_hpp_fmt *pos;
	548
	549	perf_hpp__for_each_format(pos) {
	550	if (perf_hpp__same_sort_entry(pos, fmt))
	551	goto next;
	552	}
	553	}
	554
	555	perf_hpp__column_register(fmt);
	556	next:
	557	continue;
	558	}
	559	}
	560
	561	void perf_hpp__append_sort_keys(void)
	562	{
	563	struct perf_hpp_fmt *fmt;
	564
	565	/* append output fields to sort keys */
	566	perf_hpp__for_each_format(fmt) {
	567	if (!list_empty(&fmt->sort_list))
	568	continue;
	569
	570	/*
	571	* sort entry fields are dynamically created,
	572	* so they can share a same sort key even though
	573	* the list is empty.
	574	*/
	575	if (perf_hpp__is_sort_entry(fmt)) {
	576	struct perf_hpp_fmt *pos;
	577
	578	perf_hpp__for_each_sort_list(pos) {
	579	if (perf_hpp__same_sort_entry(pos, fmt))
	580	goto next;
	581	}
	582	}
	583
	584	perf_hpp__register_sort_field(fmt);
	585	next:
	586	continue;
26d8b338 NK	587	}
	588	}
	589
1c89fe9b NK	590	void perf_hpp__reset_output_field(void)
	591	{
	592	struct perf_hpp_fmt fmt, tmp;
	593
	594	/* reset output fields */
	595	perf_hpp__for_each_format_safe(fmt, tmp) {
	596	list_del_init(&fmt->list);
	597	list_del_init(&fmt->sort_list);
	598	}
	599
	600	/* reset sort keys */
	601	perf_hpp__for_each_sort_list_safe(fmt, tmp) {
	602	list_del_init(&fmt->list);
	603	list_del_init(&fmt->sort_list);
	604	}
	605	}
	606
7e62ef44 NK	607	/*
	608	* See hists__fprintf to match the column widths
	609	*/
	610	unsigned int hists__sort_list_width(struct hists *hists)
	611	{
1240005e	612	struct perf_hpp_fmt *fmt;
cfaa154b NK	613	int ret = 0;
cfaa154b NK	614	bool first = true;
94a0793d	615	struct perf_hpp dummy_hpp;
7e62ef44	616
1240005e	617	perf_hpp__for_each_format(fmt) {
cfaa154b NK	618	if (perf_hpp__should_skip(fmt))
	619	continue;
	620
	621	if (first)
	622	first = false;
	623	else
7e62ef44 NK	624	ret += 2;
7e62ef44 NK	625
94a0793d	626	ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
7e62ef44 NK	627	}
7e62ef44 NK	628
cfaa154b	629	if (verbose && sort__has_sym) /* Addr + origin */
7e62ef44 NK	630	ret += 3 + BITS_PER_LONG / 4;
	631
	632	return ret;
	633	}
e0d66c74 NK	634
	635	void perf_hpp__reset_width(struct perf_hpp_fmt fmt, struct hists hists)
	636	{
	637	int idx;
	638
	639	if (perf_hpp__is_sort_entry(fmt))
	640	return perf_hpp__reset_sort_width(fmt, hists);
	641
	642	for (idx = 0; idx < PERF_HPP__MAX_INDEX; idx++) {
	643	if (fmt == &perf_hpp__format[idx])
	644	break;
	645	}
	646
	647	if (idx == PERF_HPP__MAX_INDEX)
	648	return;
	649
	650	switch (idx) {
	651	case PERF_HPP__OVERHEAD:
	652	case PERF_HPP__OVERHEAD_SYS:
	653	case PERF_HPP__OVERHEAD_US:
	654	case PERF_HPP__OVERHEAD_ACC:
	655	fmt->len = 8;
	656	break;
	657
	658	case PERF_HPP__OVERHEAD_GUEST_SYS:
	659	case PERF_HPP__OVERHEAD_GUEST_US:
	660	fmt->len = 9;
	661	break;
	662
	663	case PERF_HPP__SAMPLES:
	664	case PERF_HPP__PERIOD:
	665	fmt->len = 12;
	666	break;
	667
	668	default:
	669	break;
	670	}
	671	}
5b591669 NK	672
	673	void perf_hpp__set_user_width(const char *width_list_str)
	674	{
	675	struct perf_hpp_fmt *fmt;
	676	const char *ptr = width_list_str;
	677
	678	perf_hpp__for_each_format(fmt) {
	679	char *p;
	680
	681	int len = strtol(ptr, &p, 10);
	682	fmt->user_len = len;
	683
	684	if (*p == ',')
	685	ptr = p + 1;
	686	else
	687	break;
	688	}
	689	}