xref: /openbmc/linux/tools/perf/ui/hist.c (revision 1c2dd16a) 
1 #include <inttypes.h>
2 #include <math.h>
3 #include <linux/compiler.h>
4 
5 #include "../util/hist.h"
6 #include "../util/util.h"
7 #include "../util/sort.h"
8 #include "../util/evsel.h"
9 #include "../util/evlist.h"
10 
11 /* hist period print (hpp) functions */
12 
13 #define hpp__call_print_fn(hpp, fn, fmt, ...)			\
14 ({								\
15 	int __ret = fn(hpp, fmt, ##__VA_ARGS__);		\
16 	advance_hpp(hpp, __ret);				\
17 	__ret;							\
18 })
19 
20 static int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he,
21 		      hpp_field_fn get_field, const char *fmt, int len,
22 		      hpp_snprint_fn print_fn, bool fmt_percent)
23 {
24 	int ret;
25 	struct hists *hists = he->hists;
26 	struct perf_evsel *evsel = hists_to_evsel(hists);
27 	char *buf = hpp->buf;
28 	size_t size = hpp->size;
29 
30 	if (fmt_percent) {
31 		double percent = 0.0;
32 		u64 total = hists__total_period(hists);
33 
34 		if (total)
35 			percent = 100.0 * get_field(he) / total;
36 
37 		ret = hpp__call_print_fn(hpp, print_fn, fmt, len, percent);
38 	} else
39 		ret = hpp__call_print_fn(hpp, print_fn, fmt, len, get_field(he));
40 
41 	if (perf_evsel__is_group_event(evsel)) {
42 		int prev_idx, idx_delta;
43 		struct hist_entry *pair;
44 		int nr_members = evsel->nr_members;
45 
46 		prev_idx = perf_evsel__group_idx(evsel);
47 
48 		list_for_each_entry(pair, &he->pairs.head, pairs.node) {
49 			u64 period = get_field(pair);
50 			u64 total = hists__total_period(pair->hists);
51 
52 			if (!total)
53 				continue;
54 
55 			evsel = hists_to_evsel(pair->hists);
56 			idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;
57 
58 			while (idx_delta--) {
59 				/*
60 				 * zero-fill group members in the middle which
61 				 * have no sample
62 				 */
63 				if (fmt_percent) {
64 					ret += hpp__call_print_fn(hpp, print_fn,
65 								  fmt, len, 0.0);
66 				} else {
67 					ret += hpp__call_print_fn(hpp, print_fn,
68 								  fmt, len, 0ULL);
69 				}
70 			}
71 
72 			if (fmt_percent) {
73 				ret += hpp__call_print_fn(hpp, print_fn, fmt, len,
74 							  100.0 * period / total);
75 			} else {
76 				ret += hpp__call_print_fn(hpp, print_fn, fmt,
77 							  len, period);
78 			}
79 
80 			prev_idx = perf_evsel__group_idx(evsel);
81 		}
82 
83 		idx_delta = nr_members - prev_idx - 1;
84 
85 		while (idx_delta--) {
86 			/*
87 			 * zero-fill group members at last which have no sample
88 			 */
89 			if (fmt_percent) {
90 				ret += hpp__call_print_fn(hpp, print_fn,
91 							  fmt, len, 0.0);
92 			} else {
93 				ret += hpp__call_print_fn(hpp, print_fn,
94 							  fmt, len, 0ULL);
95 			}
96 		}
97 	}
98 
99 	/*
100 	 * Restore original buf and size as it's where caller expects
101 	 * the result will be saved.
102 	 */
103 	hpp->buf = buf;
104 	hpp->size = size;
105 
106 	return ret;
107 }
108 
109 int hpp__fmt(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
110 	     struct hist_entry *he, hpp_field_fn get_field,
111 	     const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent)
112 {
113 	int len = fmt->user_len ?: fmt->len;
114 
115 	if (symbol_conf.field_sep) {
116 		return __hpp__fmt(hpp, he, get_field, fmtstr, 1,
117 				  print_fn, fmt_percent);
118 	}
119 
120 	if (fmt_percent)
121 		len -= 2; /* 2 for a space and a % sign */
122 	else
123 		len -= 1;
124 
125 	return  __hpp__fmt(hpp, he, get_field, fmtstr, len, print_fn, fmt_percent);
126 }
127 
128 int hpp__fmt_acc(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
129 		 struct hist_entry *he, hpp_field_fn get_field,
130 		 const char *fmtstr, hpp_snprint_fn print_fn, bool fmt_percent)
131 {
132 	if (!symbol_conf.cumulate_callchain) {
133 		int len = fmt->user_len ?: fmt->len;
134 		return snprintf(hpp->buf, hpp->size, " %*s", len - 1, "N/A");
135 	}
136 
137 	return hpp__fmt(fmt, hpp, he, get_field, fmtstr, print_fn, fmt_percent);
138 }
139 
140 static int field_cmp(u64 field_a, u64 field_b)
141 {
142 	if (field_a > field_b)
143 		return 1;
144 	if (field_a < field_b)
145 		return -1;
146 	return 0;
147 }
148 
149 static int __hpp__sort(struct hist_entry *a, struct hist_entry *b,
150 		       hpp_field_fn get_field)
151 {
152 	s64 ret;
153 	int i, nr_members;
154 	struct perf_evsel *evsel;
155 	struct hist_entry *pair;
156 	u64 *fields_a, *fields_b;
157 
158 	ret = field_cmp(get_field(a), get_field(b));
159 	if (ret || !symbol_conf.event_group)
160 		return ret;
161 
162 	evsel = hists_to_evsel(a->hists);
163 	if (!perf_evsel__is_group_event(evsel))
164 		return ret;
165 
166 	nr_members = evsel->nr_members;
167 	fields_a = calloc(nr_members, sizeof(*fields_a));
168 	fields_b = calloc(nr_members, sizeof(*fields_b));
169 
170 	if (!fields_a || !fields_b)
171 		goto out;
172 
173 	list_for_each_entry(pair, &a->pairs.head, pairs.node) {
174 		evsel = hists_to_evsel(pair->hists);
175 		fields_a[perf_evsel__group_idx(evsel)] = get_field(pair);
176 	}
177 
178 	list_for_each_entry(pair, &b->pairs.head, pairs.node) {
179 		evsel = hists_to_evsel(pair->hists);
180 		fields_b[perf_evsel__group_idx(evsel)] = get_field(pair);
181 	}
182 
183 	for (i = 1; i < nr_members; i++) {
184 		ret = field_cmp(fields_a[i], fields_b[i]);
185 		if (ret)
186 			break;
187 	}
188 
189 out:
190 	free(fields_a);
191 	free(fields_b);
192 
193 	return ret;
194 }
195 
196 static int __hpp__sort_acc(struct hist_entry *a, struct hist_entry *b,
197 			   hpp_field_fn get_field)
198 {
199 	s64 ret = 0;
200 
201 	if (symbol_conf.cumulate_callchain) {
202 		/*
203 		 * Put caller above callee when they have equal period.
204 		 */
205 		ret = field_cmp(get_field(a), get_field(b));
206 		if (ret)
207 			return ret;
208 
209 		if (a->thread != b->thread || !symbol_conf.use_callchain)
210 			return 0;
211 
212 		ret = b->callchain->max_depth - a->callchain->max_depth;
213 	}
214 	return ret;
215 }
216 
217 static int hpp__width_fn(struct perf_hpp_fmt *fmt,
218 			 struct perf_hpp *hpp __maybe_unused,
219 			 struct hists *hists)
220 {
221 	int len = fmt->user_len ?: fmt->len;
222 	struct perf_evsel *evsel = hists_to_evsel(hists);
223 
224 	if (symbol_conf.event_group)
225 		len = max(len, evsel->nr_members * fmt->len);
226 
227 	if (len < (int)strlen(fmt->name))
228 		len = strlen(fmt->name);
229 
230 	return len;
231 }
232 
233 static int hpp__header_fn(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
234 			  struct hists *hists, int line __maybe_unused,
235 			  int *span __maybe_unused)
236 {
237 	int len = hpp__width_fn(fmt, hpp, hists);
238 	return scnprintf(hpp->buf, hpp->size, "%*s", len, fmt->name);
239 }
240 
241 int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
242 {
243 	va_list args;
244 	ssize_t ssize = hpp->size;
245 	double percent;
246 	int ret, len;
247 
248 	va_start(args, fmt);
249 	len = va_arg(args, int);
250 	percent = va_arg(args, double);
251 	ret = percent_color_len_snprintf(hpp->buf, hpp->size, fmt, len, percent);
252 	va_end(args);
253 
254 	return (ret >= ssize) ? (ssize - 1) : ret;
255 }
256 
257 static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
258 {
259 	va_list args;
260 	ssize_t ssize = hpp->size;
261 	int ret;
262 
263 	va_start(args, fmt);
264 	ret = vsnprintf(hpp->buf, hpp->size, fmt, args);
265 	va_end(args);
266 
267 	return (ret >= ssize) ? (ssize - 1) : ret;
268 }
269 
270 #define __HPP_COLOR_PERCENT_FN(_type, _field)					\
271 static u64 he_get_##_field(struct hist_entry *he)				\
272 {										\
273 	return he->stat._field;							\
274 }										\
275 										\
276 static int hpp__color_##_type(struct perf_hpp_fmt *fmt,				\
277 			      struct perf_hpp *hpp, struct hist_entry *he) 	\
278 {										\
279 	return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%",		\
280 			hpp_color_scnprintf, true);				\
281 }
282 
283 #define __HPP_ENTRY_PERCENT_FN(_type, _field)					\
284 static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,				\
285 			      struct perf_hpp *hpp, struct hist_entry *he) 	\
286 {										\
287 	return hpp__fmt(fmt, hpp, he, he_get_##_field, " %*.2f%%",		\
288 			hpp_entry_scnprintf, true);				\
289 }
290 
291 #define __HPP_SORT_FN(_type, _field)						\
292 static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused, 	\
293 				 struct hist_entry *a, struct hist_entry *b) 	\
294 {										\
295 	return __hpp__sort(a, b, he_get_##_field);				\
296 }
297 
298 #define __HPP_COLOR_ACC_PERCENT_FN(_type, _field)				\
299 static u64 he_get_acc_##_field(struct hist_entry *he)				\
300 {										\
301 	return he->stat_acc->_field;						\
302 }										\
303 										\
304 static int hpp__color_##_type(struct perf_hpp_fmt *fmt,				\
305 			      struct perf_hpp *hpp, struct hist_entry *he) 	\
306 {										\
307 	return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%", 	\
308 			    hpp_color_scnprintf, true);				\
309 }
310 
311 #define __HPP_ENTRY_ACC_PERCENT_FN(_type, _field)				\
312 static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,				\
313 			      struct perf_hpp *hpp, struct hist_entry *he) 	\
314 {										\
315 	return hpp__fmt_acc(fmt, hpp, he, he_get_acc_##_field, " %*.2f%%",	\
316 			    hpp_entry_scnprintf, true);				\
317 }
318 
319 #define __HPP_SORT_ACC_FN(_type, _field)					\
320 static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused, 	\
321 				 struct hist_entry *a, struct hist_entry *b) 	\
322 {										\
323 	return __hpp__sort_acc(a, b, he_get_acc_##_field);			\
324 }
325 
326 #define __HPP_ENTRY_RAW_FN(_type, _field)					\
327 static u64 he_get_raw_##_field(struct hist_entry *he)				\
328 {										\
329 	return he->stat._field;							\
330 }										\
331 										\
332 static int hpp__entry_##_type(struct perf_hpp_fmt *fmt,				\
333 			      struct perf_hpp *hpp, struct hist_entry *he) 	\
334 {										\
335 	return hpp__fmt(fmt, hpp, he, he_get_raw_##_field, " %*"PRIu64, 	\
336 			hpp_entry_scnprintf, false);				\
337 }
338 
339 #define __HPP_SORT_RAW_FN(_type, _field)					\
340 static int64_t hpp__sort_##_type(struct perf_hpp_fmt *fmt __maybe_unused, 	\
341 				 struct hist_entry *a, struct hist_entry *b) 	\
342 {										\
343 	return __hpp__sort(a, b, he_get_raw_##_field);				\
344 }
345 
346 
347 #define HPP_PERCENT_FNS(_type, _field)					\
348 __HPP_COLOR_PERCENT_FN(_type, _field)					\
349 __HPP_ENTRY_PERCENT_FN(_type, _field)					\
350 __HPP_SORT_FN(_type, _field)
351 
352 #define HPP_PERCENT_ACC_FNS(_type, _field)				\
353 __HPP_COLOR_ACC_PERCENT_FN(_type, _field)				\
354 __HPP_ENTRY_ACC_PERCENT_FN(_type, _field)				\
355 __HPP_SORT_ACC_FN(_type, _field)
356 
357 #define HPP_RAW_FNS(_type, _field)					\
358 __HPP_ENTRY_RAW_FN(_type, _field)					\
359 __HPP_SORT_RAW_FN(_type, _field)
360 
361 HPP_PERCENT_FNS(overhead, period)
362 HPP_PERCENT_FNS(overhead_sys, period_sys)
363 HPP_PERCENT_FNS(overhead_us, period_us)
364 HPP_PERCENT_FNS(overhead_guest_sys, period_guest_sys)
365 HPP_PERCENT_FNS(overhead_guest_us, period_guest_us)
366 HPP_PERCENT_ACC_FNS(overhead_acc, period)
367 
368 HPP_RAW_FNS(samples, nr_events)
369 HPP_RAW_FNS(period, period)
370 
371 static int64_t hpp__nop_cmp(struct perf_hpp_fmt *fmt __maybe_unused,
372 			    struct hist_entry *a __maybe_unused,
373 			    struct hist_entry *b __maybe_unused)
374 {
375 	return 0;
376 }
377 
378 static bool perf_hpp__is_hpp_entry(struct perf_hpp_fmt *a)
379 {
380 	return a->header == hpp__header_fn;
381 }
382 
383 static bool hpp__equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
384 {
385 	if (!perf_hpp__is_hpp_entry(a) || !perf_hpp__is_hpp_entry(b))
386 		return false;
387 
388 	return a->idx == b->idx;
389 }
390 
391 #define HPP__COLOR_PRINT_FNS(_name, _fn, _idx)		\
392 	{						\
393 		.name   = _name,			\
394 		.header	= hpp__header_fn,		\
395 		.width	= hpp__width_fn,		\
396 		.color	= hpp__color_ ## _fn,		\
397 		.entry	= hpp__entry_ ## _fn,		\
398 		.cmp	= hpp__nop_cmp,			\
399 		.collapse = hpp__nop_cmp,		\
400 		.sort	= hpp__sort_ ## _fn,		\
401 		.idx	= PERF_HPP__ ## _idx,		\
402 		.equal	= hpp__equal,			\
403 	}
404 
405 #define HPP__COLOR_ACC_PRINT_FNS(_name, _fn, _idx)	\
406 	{						\
407 		.name   = _name,			\
408 		.header	= hpp__header_fn,		\
409 		.width	= hpp__width_fn,		\
410 		.color	= hpp__color_ ## _fn,		\
411 		.entry	= hpp__entry_ ## _fn,		\
412 		.cmp	= hpp__nop_cmp,			\
413 		.collapse = hpp__nop_cmp,		\
414 		.sort	= hpp__sort_ ## _fn,		\
415 		.idx	= PERF_HPP__ ## _idx,		\
416 		.equal	= hpp__equal,			\
417 	}
418 
419 #define HPP__PRINT_FNS(_name, _fn, _idx)		\
420 	{						\
421 		.name   = _name,			\
422 		.header	= hpp__header_fn,		\
423 		.width	= hpp__width_fn,		\
424 		.entry	= hpp__entry_ ## _fn,		\
425 		.cmp	= hpp__nop_cmp,			\
426 		.collapse = hpp__nop_cmp,		\
427 		.sort	= hpp__sort_ ## _fn,		\
428 		.idx	= PERF_HPP__ ## _idx,		\
429 		.equal	= hpp__equal,			\
430 	}
431 
432 struct perf_hpp_fmt perf_hpp__format[] = {
433 	HPP__COLOR_PRINT_FNS("Overhead", overhead, OVERHEAD),
434 	HPP__COLOR_PRINT_FNS("sys", overhead_sys, OVERHEAD_SYS),
435 	HPP__COLOR_PRINT_FNS("usr", overhead_us, OVERHEAD_US),
436 	HPP__COLOR_PRINT_FNS("guest sys", overhead_guest_sys, OVERHEAD_GUEST_SYS),
437 	HPP__COLOR_PRINT_FNS("guest usr", overhead_guest_us, OVERHEAD_GUEST_US),
438 	HPP__COLOR_ACC_PRINT_FNS("Children", overhead_acc, OVERHEAD_ACC),
439 	HPP__PRINT_FNS("Samples", samples, SAMPLES),
440 	HPP__PRINT_FNS("Period", period, PERIOD)
441 };
442 
443 struct perf_hpp_list perf_hpp_list = {
444 	.fields	= LIST_HEAD_INIT(perf_hpp_list.fields),
445 	.sorts	= LIST_HEAD_INIT(perf_hpp_list.sorts),
446 	.nr_header_lines = 1,
447 };
448 
449 #undef HPP__COLOR_PRINT_FNS
450 #undef HPP__COLOR_ACC_PRINT_FNS
451 #undef HPP__PRINT_FNS
452 
453 #undef HPP_PERCENT_FNS
454 #undef HPP_PERCENT_ACC_FNS
455 #undef HPP_RAW_FNS
456 
457 #undef __HPP_HEADER_FN
458 #undef __HPP_WIDTH_FN
459 #undef __HPP_COLOR_PERCENT_FN
460 #undef __HPP_ENTRY_PERCENT_FN
461 #undef __HPP_COLOR_ACC_PERCENT_FN
462 #undef __HPP_ENTRY_ACC_PERCENT_FN
463 #undef __HPP_ENTRY_RAW_FN
464 #undef __HPP_SORT_FN
465 #undef __HPP_SORT_ACC_FN
466 #undef __HPP_SORT_RAW_FN
467 
468 
469 void perf_hpp__init(void)
470 {
471 	int i;
472 
473 	for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
474 		struct perf_hpp_fmt *fmt = &perf_hpp__format[i];
475 
476 		INIT_LIST_HEAD(&fmt->list);
477 
478 		/* sort_list may be linked by setup_sorting() */
479 		if (fmt->sort_list.next == NULL)
480 			INIT_LIST_HEAD(&fmt->sort_list);
481 	}
482 
483 	/*
484 	 * If user specified field order, no need to setup default fields.
485 	 */
486 	if (is_strict_order(field_order))
487 		return;
488 
489 	if (symbol_conf.cumulate_callchain) {
490 		hpp_dimension__add_output(PERF_HPP__OVERHEAD_ACC);
491 		perf_hpp__format[PERF_HPP__OVERHEAD].name = "Self";
492 	}
493 
494 	hpp_dimension__add_output(PERF_HPP__OVERHEAD);
495 
496 	if (symbol_conf.show_cpu_utilization) {
497 		hpp_dimension__add_output(PERF_HPP__OVERHEAD_SYS);
498 		hpp_dimension__add_output(PERF_HPP__OVERHEAD_US);
499 
500 		if (perf_guest) {
501 			hpp_dimension__add_output(PERF_HPP__OVERHEAD_GUEST_SYS);
502 			hpp_dimension__add_output(PERF_HPP__OVERHEAD_GUEST_US);
503 		}
504 	}
505 
506 	if (symbol_conf.show_nr_samples)
507 		hpp_dimension__add_output(PERF_HPP__SAMPLES);
508 
509 	if (symbol_conf.show_total_period)
510 		hpp_dimension__add_output(PERF_HPP__PERIOD);
511 }
512 
513 void perf_hpp_list__column_register(struct perf_hpp_list *list,
514 				    struct perf_hpp_fmt *format)
515 {
516 	list_add_tail(&format->list, &list->fields);
517 }
518 
519 void perf_hpp_list__register_sort_field(struct perf_hpp_list *list,
520 					struct perf_hpp_fmt *format)
521 {
522 	list_add_tail(&format->sort_list, &list->sorts);
523 }
524 
525 void perf_hpp_list__prepend_sort_field(struct perf_hpp_list *list,
526 				       struct perf_hpp_fmt *format)
527 {
528 	list_add(&format->sort_list, &list->sorts);
529 }
530 
531 void perf_hpp__column_unregister(struct perf_hpp_fmt *format)
532 {
533 	list_del(&format->list);
534 }
535 
536 void perf_hpp__cancel_cumulate(void)
537 {
538 	struct perf_hpp_fmt *fmt, *acc, *ovh, *tmp;
539 
540 	if (is_strict_order(field_order))
541 		return;
542 
543 	ovh = &perf_hpp__format[PERF_HPP__OVERHEAD];
544 	acc = &perf_hpp__format[PERF_HPP__OVERHEAD_ACC];
545 
546 	perf_hpp_list__for_each_format_safe(&perf_hpp_list, fmt, tmp) {
547 		if (acc->equal(acc, fmt)) {
548 			perf_hpp__column_unregister(fmt);
549 			continue;
550 		}
551 
552 		if (ovh->equal(ovh, fmt))
553 			fmt->name = "Overhead";
554 	}
555 }
556 
557 static bool fmt_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
558 {
559 	return a->equal && a->equal(a, b);
560 }
561 
562 void perf_hpp__setup_output_field(struct perf_hpp_list *list)
563 {
564 	struct perf_hpp_fmt *fmt;
565 
566 	/* append sort keys to output field */
567 	perf_hpp_list__for_each_sort_list(list, fmt) {
568 		struct perf_hpp_fmt *pos;
569 
570 		/* skip sort-only fields ("sort_compute" in perf diff) */
571 		if (!fmt->entry && !fmt->color)
572 			continue;
573 
574 		perf_hpp_list__for_each_format(list, pos) {
575 			if (fmt_equal(fmt, pos))
576 				goto next;
577 		}
578 
579 		perf_hpp__column_register(fmt);
580 next:
581 		continue;
582 	}
583 }
584 
585 void perf_hpp__append_sort_keys(struct perf_hpp_list *list)
586 {
587 	struct perf_hpp_fmt *fmt;
588 
589 	/* append output fields to sort keys */
590 	perf_hpp_list__for_each_format(list, fmt) {
591 		struct perf_hpp_fmt *pos;
592 
593 		perf_hpp_list__for_each_sort_list(list, pos) {
594 			if (fmt_equal(fmt, pos))
595 				goto next;
596 		}
597 
598 		perf_hpp__register_sort_field(fmt);
599 next:
600 		continue;
601 	}
602 }
603 
604 
605 static void fmt_free(struct perf_hpp_fmt *fmt)
606 {
607 	if (fmt->free)
608 		fmt->free(fmt);
609 }
610 
611 void perf_hpp__reset_output_field(struct perf_hpp_list *list)
612 {
613 	struct perf_hpp_fmt *fmt, *tmp;
614 
615 	/* reset output fields */
616 	perf_hpp_list__for_each_format_safe(list, fmt, tmp) {
617 		list_del_init(&fmt->list);
618 		list_del_init(&fmt->sort_list);
619 		fmt_free(fmt);
620 	}
621 
622 	/* reset sort keys */
623 	perf_hpp_list__for_each_sort_list_safe(list, fmt, tmp) {
624 		list_del_init(&fmt->list);
625 		list_del_init(&fmt->sort_list);
626 		fmt_free(fmt);
627 	}
628 }
629 
630 /*
631  * See hists__fprintf to match the column widths
632  */
633 unsigned int hists__sort_list_width(struct hists *hists)
634 {
635 	struct perf_hpp_fmt *fmt;
636 	int ret = 0;
637 	bool first = true;
638 	struct perf_hpp dummy_hpp;
639 
640 	hists__for_each_format(hists, fmt) {
641 		if (perf_hpp__should_skip(fmt, hists))
642 			continue;
643 
644 		if (first)
645 			first = false;
646 		else
647 			ret += 2;
648 
649 		ret += fmt->width(fmt, &dummy_hpp, hists);
650 	}
651 
652 	if (verbose > 0 && hists__has(hists, sym)) /* Addr + origin */
653 		ret += 3 + BITS_PER_LONG / 4;
654 
655 	return ret;
656 }
657 
658 unsigned int hists__overhead_width(struct hists *hists)
659 {
660 	struct perf_hpp_fmt *fmt;
661 	int ret = 0;
662 	bool first = true;
663 	struct perf_hpp dummy_hpp;
664 
665 	hists__for_each_format(hists, fmt) {
666 		if (perf_hpp__is_sort_entry(fmt) || perf_hpp__is_dynamic_entry(fmt))
667 			break;
668 
669 		if (first)
670 			first = false;
671 		else
672 			ret += 2;
673 
674 		ret += fmt->width(fmt, &dummy_hpp, hists);
675 	}
676 
677 	return ret;
678 }
679 
680 void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists)
681 {
682 	if (perf_hpp__is_sort_entry(fmt))
683 		return perf_hpp__reset_sort_width(fmt, hists);
684 
685 	if (perf_hpp__is_dynamic_entry(fmt))
686 		return;
687 
688 	BUG_ON(fmt->idx >= PERF_HPP__MAX_INDEX);
689 
690 	switch (fmt->idx) {
691 	case PERF_HPP__OVERHEAD:
692 	case PERF_HPP__OVERHEAD_SYS:
693 	case PERF_HPP__OVERHEAD_US:
694 	case PERF_HPP__OVERHEAD_ACC:
695 		fmt->len = 8;
696 		break;
697 
698 	case PERF_HPP__OVERHEAD_GUEST_SYS:
699 	case PERF_HPP__OVERHEAD_GUEST_US:
700 		fmt->len = 9;
701 		break;
702 
703 	case PERF_HPP__SAMPLES:
704 	case PERF_HPP__PERIOD:
705 		fmt->len = 12;
706 		break;
707 
708 	default:
709 		break;
710 	}
711 }
712 
713 void hists__reset_column_width(struct hists *hists)
714 {
715 	struct perf_hpp_fmt *fmt;
716 	struct perf_hpp_list_node *node;
717 
718 	hists__for_each_format(hists, fmt)
719 		perf_hpp__reset_width(fmt, hists);
720 
721 	/* hierarchy entries have their own hpp list */
722 	list_for_each_entry(node, &hists->hpp_formats, list) {
723 		perf_hpp_list__for_each_format(&node->hpp, fmt)
724 			perf_hpp__reset_width(fmt, hists);
725 	}
726 }
727 
728 void perf_hpp__set_user_width(const char *width_list_str)
729 {
730 	struct perf_hpp_fmt *fmt;
731 	const char *ptr = width_list_str;
732 
733 	perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
734 		char *p;
735 
736 		int len = strtol(ptr, &p, 10);
737 		fmt->user_len = len;
738 
739 		if (*p == ',')
740 			ptr = p + 1;
741 		else
742 			break;
743 	}
744 }
745 
746 static int add_hierarchy_fmt(struct hists *hists, struct perf_hpp_fmt *fmt)
747 {
748 	struct perf_hpp_list_node *node = NULL;
749 	struct perf_hpp_fmt *fmt_copy;
750 	bool found = false;
751 	bool skip = perf_hpp__should_skip(fmt, hists);
752 
753 	list_for_each_entry(node, &hists->hpp_formats, list) {
754 		if (node->level == fmt->level) {
755 			found = true;
756 			break;
757 		}
758 	}
759 
760 	if (!found) {
761 		node = malloc(sizeof(*node));
762 		if (node == NULL)
763 			return -1;
764 
765 		node->skip = skip;
766 		node->level = fmt->level;
767 		perf_hpp_list__init(&node->hpp);
768 
769 		hists->nr_hpp_node++;
770 		list_add_tail(&node->list, &hists->hpp_formats);
771 	}
772 
773 	fmt_copy = perf_hpp_fmt__dup(fmt);
774 	if (fmt_copy == NULL)
775 		return -1;
776 
777 	if (!skip)
778 		node->skip = false;
779 
780 	list_add_tail(&fmt_copy->list, &node->hpp.fields);
781 	list_add_tail(&fmt_copy->sort_list, &node->hpp.sorts);
782 
783 	return 0;
784 }
785 
786 int perf_hpp__setup_hists_formats(struct perf_hpp_list *list,
787 				  struct perf_evlist *evlist)
788 {
789 	struct perf_evsel *evsel;
790 	struct perf_hpp_fmt *fmt;
791 	struct hists *hists;
792 	int ret;
793 
794 	if (!symbol_conf.report_hierarchy)
795 		return 0;
796 
797 	evlist__for_each_entry(evlist, evsel) {
798 		hists = evsel__hists(evsel);
799 
800 		perf_hpp_list__for_each_sort_list(list, fmt) {
801 			if (perf_hpp__is_dynamic_entry(fmt) &&
802 			    !perf_hpp__defined_dynamic_entry(fmt, hists))
803 				continue;
804 
805 			ret = add_hierarchy_fmt(hists, fmt);
806 			if (ret < 0)
807 				return ret;
808 		}
809 	}
810 
811 	return 0;
812 }
813