xref: /openbmc/linux/tools/perf/builtin-diff.c (revision e8f6f3b4)
1 /*
2  * builtin-diff.c
3  *
4  * Builtin diff command: Analyze two perf.data input files, look up and read
5  * DSOs and symbol information, sort them and produce a diff.
6  */
7 #include "builtin.h"
8 
9 #include "util/debug.h"
10 #include "util/event.h"
11 #include "util/hist.h"
12 #include "util/evsel.h"
13 #include "util/evlist.h"
14 #include "util/session.h"
15 #include "util/tool.h"
16 #include "util/sort.h"
17 #include "util/symbol.h"
18 #include "util/util.h"
19 #include "util/data.h"
20 
21 #include <stdlib.h>
22 #include <math.h>
23 
24 /* Diff command specific HPP columns. */
25 enum {
26 	PERF_HPP_DIFF__BASELINE,
27 	PERF_HPP_DIFF__PERIOD,
28 	PERF_HPP_DIFF__PERIOD_BASELINE,
29 	PERF_HPP_DIFF__DELTA,
30 	PERF_HPP_DIFF__RATIO,
31 	PERF_HPP_DIFF__WEIGHTED_DIFF,
32 	PERF_HPP_DIFF__FORMULA,
33 
34 	PERF_HPP_DIFF__MAX_INDEX
35 };
36 
37 struct diff_hpp_fmt {
38 	struct perf_hpp_fmt	 fmt;
39 	int			 idx;
40 	char			*header;
41 	int			 header_width;
42 };
43 
44 struct data__file {
45 	struct perf_session	*session;
46 	struct perf_data_file	file;
47 	int			 idx;
48 	struct hists		*hists;
49 	struct diff_hpp_fmt	 fmt[PERF_HPP_DIFF__MAX_INDEX];
50 };
51 
52 static struct data__file *data__files;
53 static int data__files_cnt;
54 
55 #define data__for_each_file_start(i, d, s)	\
56 	for (i = s, d = &data__files[s];	\
57 	     i < data__files_cnt;		\
58 	     i++, d = &data__files[i])
59 
60 #define data__for_each_file(i, d) data__for_each_file_start(i, d, 0)
61 #define data__for_each_file_new(i, d) data__for_each_file_start(i, d, 1)
62 
63 static bool force;
64 static bool show_period;
65 static bool show_formula;
66 static bool show_baseline_only;
67 static unsigned int sort_compute;
68 
69 static s64 compute_wdiff_w1;
70 static s64 compute_wdiff_w2;
71 
72 enum {
73 	COMPUTE_DELTA,
74 	COMPUTE_RATIO,
75 	COMPUTE_WEIGHTED_DIFF,
76 	COMPUTE_MAX,
77 };
78 
79 const char *compute_names[COMPUTE_MAX] = {
80 	[COMPUTE_DELTA] = "delta",
81 	[COMPUTE_RATIO] = "ratio",
82 	[COMPUTE_WEIGHTED_DIFF] = "wdiff",
83 };
84 
85 static int compute;
86 
87 static int compute_2_hpp[COMPUTE_MAX] = {
88 	[COMPUTE_DELTA]		= PERF_HPP_DIFF__DELTA,
89 	[COMPUTE_RATIO]		= PERF_HPP_DIFF__RATIO,
90 	[COMPUTE_WEIGHTED_DIFF]	= PERF_HPP_DIFF__WEIGHTED_DIFF,
91 };
92 
93 #define MAX_COL_WIDTH 70
94 
95 static struct header_column {
96 	const char *name;
97 	int width;
98 } columns[PERF_HPP_DIFF__MAX_INDEX] = {
99 	[PERF_HPP_DIFF__BASELINE] = {
100 		.name  = "Baseline",
101 	},
102 	[PERF_HPP_DIFF__PERIOD] = {
103 		.name  = "Period",
104 		.width = 14,
105 	},
106 	[PERF_HPP_DIFF__PERIOD_BASELINE] = {
107 		.name  = "Base period",
108 		.width = 14,
109 	},
110 	[PERF_HPP_DIFF__DELTA] = {
111 		.name  = "Delta",
112 		.width = 7,
113 	},
114 	[PERF_HPP_DIFF__RATIO] = {
115 		.name  = "Ratio",
116 		.width = 14,
117 	},
118 	[PERF_HPP_DIFF__WEIGHTED_DIFF] = {
119 		.name  = "Weighted diff",
120 		.width = 14,
121 	},
122 	[PERF_HPP_DIFF__FORMULA] = {
123 		.name  = "Formula",
124 		.width = MAX_COL_WIDTH,
125 	}
126 };
127 
128 static int setup_compute_opt_wdiff(char *opt)
129 {
130 	char *w1_str = opt;
131 	char *w2_str;
132 
133 	int ret = -EINVAL;
134 
135 	if (!opt)
136 		goto out;
137 
138 	w2_str = strchr(opt, ',');
139 	if (!w2_str)
140 		goto out;
141 
142 	*w2_str++ = 0x0;
143 	if (!*w2_str)
144 		goto out;
145 
146 	compute_wdiff_w1 = strtol(w1_str, NULL, 10);
147 	compute_wdiff_w2 = strtol(w2_str, NULL, 10);
148 
149 	if (!compute_wdiff_w1 || !compute_wdiff_w2)
150 		goto out;
151 
152 	pr_debug("compute wdiff w1(%" PRId64 ") w2(%" PRId64 ")\n",
153 		  compute_wdiff_w1, compute_wdiff_w2);
154 
155 	ret = 0;
156 
157  out:
158 	if (ret)
159 		pr_err("Failed: wrong weight data, use 'wdiff:w1,w2'\n");
160 
161 	return ret;
162 }
163 
164 static int setup_compute_opt(char *opt)
165 {
166 	if (compute == COMPUTE_WEIGHTED_DIFF)
167 		return setup_compute_opt_wdiff(opt);
168 
169 	if (opt) {
170 		pr_err("Failed: extra option specified '%s'", opt);
171 		return -EINVAL;
172 	}
173 
174 	return 0;
175 }
176 
177 static int setup_compute(const struct option *opt, const char *str,
178 			 int unset __maybe_unused)
179 {
180 	int *cp = (int *) opt->value;
181 	char *cstr = (char *) str;
182 	char buf[50];
183 	unsigned i;
184 	char *option;
185 
186 	if (!str) {
187 		*cp = COMPUTE_DELTA;
188 		return 0;
189 	}
190 
191 	option = strchr(str, ':');
192 	if (option) {
193 		unsigned len = option++ - str;
194 
195 		/*
196 		 * The str data are not writeable, so we need
197 		 * to use another buffer.
198 		 */
199 
200 		/* No option value is longer. */
201 		if (len >= sizeof(buf))
202 			return -EINVAL;
203 
204 		strncpy(buf, str, len);
205 		buf[len] = 0x0;
206 		cstr = buf;
207 	}
208 
209 	for (i = 0; i < COMPUTE_MAX; i++)
210 		if (!strcmp(cstr, compute_names[i])) {
211 			*cp = i;
212 			return setup_compute_opt(option);
213 		}
214 
215 	pr_err("Failed: '%s' is not computation method "
216 	       "(use 'delta','ratio' or 'wdiff')\n", str);
217 	return -EINVAL;
218 }
219 
220 static double period_percent(struct hist_entry *he, u64 period)
221 {
222 	u64 total = hists__total_period(he->hists);
223 
224 	return (period * 100.0) / total;
225 }
226 
227 static double compute_delta(struct hist_entry *he, struct hist_entry *pair)
228 {
229 	double old_percent = period_percent(he, he->stat.period);
230 	double new_percent = period_percent(pair, pair->stat.period);
231 
232 	pair->diff.period_ratio_delta = new_percent - old_percent;
233 	pair->diff.computed = true;
234 	return pair->diff.period_ratio_delta;
235 }
236 
237 static double compute_ratio(struct hist_entry *he, struct hist_entry *pair)
238 {
239 	double old_period = he->stat.period ?: 1;
240 	double new_period = pair->stat.period;
241 
242 	pair->diff.computed = true;
243 	pair->diff.period_ratio = new_period / old_period;
244 	return pair->diff.period_ratio;
245 }
246 
247 static s64 compute_wdiff(struct hist_entry *he, struct hist_entry *pair)
248 {
249 	u64 old_period = he->stat.period;
250 	u64 new_period = pair->stat.period;
251 
252 	pair->diff.computed = true;
253 	pair->diff.wdiff = new_period * compute_wdiff_w2 -
254 			   old_period * compute_wdiff_w1;
255 
256 	return pair->diff.wdiff;
257 }
258 
259 static int formula_delta(struct hist_entry *he, struct hist_entry *pair,
260 			 char *buf, size_t size)
261 {
262 	u64 he_total = he->hists->stats.total_period;
263 	u64 pair_total = pair->hists->stats.total_period;
264 
265 	if (symbol_conf.filter_relative) {
266 		he_total = he->hists->stats.total_non_filtered_period;
267 		pair_total = pair->hists->stats.total_non_filtered_period;
268 	}
269 	return scnprintf(buf, size,
270 			 "(%" PRIu64 " * 100 / %" PRIu64 ") - "
271 			 "(%" PRIu64 " * 100 / %" PRIu64 ")",
272 			 pair->stat.period, pair_total,
273 			 he->stat.period, he_total);
274 }
275 
276 static int formula_ratio(struct hist_entry *he, struct hist_entry *pair,
277 			 char *buf, size_t size)
278 {
279 	double old_period = he->stat.period;
280 	double new_period = pair->stat.period;
281 
282 	return scnprintf(buf, size, "%.0F / %.0F", new_period, old_period);
283 }
284 
285 static int formula_wdiff(struct hist_entry *he, struct hist_entry *pair,
286 			 char *buf, size_t size)
287 {
288 	u64 old_period = he->stat.period;
289 	u64 new_period = pair->stat.period;
290 
291 	return scnprintf(buf, size,
292 		  "(%" PRIu64 " * " "%" PRId64 ") - (%" PRIu64 " * " "%" PRId64 ")",
293 		  new_period, compute_wdiff_w2, old_period, compute_wdiff_w1);
294 }
295 
296 static int formula_fprintf(struct hist_entry *he, struct hist_entry *pair,
297 			   char *buf, size_t size)
298 {
299 	switch (compute) {
300 	case COMPUTE_DELTA:
301 		return formula_delta(he, pair, buf, size);
302 	case COMPUTE_RATIO:
303 		return formula_ratio(he, pair, buf, size);
304 	case COMPUTE_WEIGHTED_DIFF:
305 		return formula_wdiff(he, pair, buf, size);
306 	default:
307 		BUG_ON(1);
308 	}
309 
310 	return -1;
311 }
312 
313 static int hists__add_entry(struct hists *hists,
314 			    struct addr_location *al, u64 period,
315 			    u64 weight, u64 transaction)
316 {
317 	if (__hists__add_entry(hists, al, NULL, NULL, NULL, period, weight,
318 			       transaction, true) != NULL)
319 		return 0;
320 	return -ENOMEM;
321 }
322 
323 static int diff__process_sample_event(struct perf_tool *tool __maybe_unused,
324 				      union perf_event *event,
325 				      struct perf_sample *sample,
326 				      struct perf_evsel *evsel,
327 				      struct machine *machine)
328 {
329 	struct addr_location al;
330 	struct hists *hists = evsel__hists(evsel);
331 
332 	if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
333 		pr_warning("problem processing %d event, skipping it.\n",
334 			   event->header.type);
335 		return -1;
336 	}
337 
338 	if (hists__add_entry(hists, &al, sample->period,
339 			     sample->weight, sample->transaction)) {
340 		pr_warning("problem incrementing symbol period, skipping event\n");
341 		return -1;
342 	}
343 
344 	/*
345 	 * The total_period is updated here before going to the output
346 	 * tree since normally only the baseline hists will call
347 	 * hists__output_resort() and precompute needs the total
348 	 * period in order to sort entries by percentage delta.
349 	 */
350 	hists->stats.total_period += sample->period;
351 	if (!al.filtered)
352 		hists->stats.total_non_filtered_period += sample->period;
353 
354 	return 0;
355 }
356 
357 static struct perf_tool tool = {
358 	.sample	= diff__process_sample_event,
359 	.mmap	= perf_event__process_mmap,
360 	.mmap2	= perf_event__process_mmap2,
361 	.comm	= perf_event__process_comm,
362 	.exit	= perf_event__process_exit,
363 	.fork	= perf_event__process_fork,
364 	.lost	= perf_event__process_lost,
365 	.ordered_events = true,
366 	.ordering_requires_timestamps = true,
367 };
368 
369 static struct perf_evsel *evsel_match(struct perf_evsel *evsel,
370 				      struct perf_evlist *evlist)
371 {
372 	struct perf_evsel *e;
373 
374 	evlist__for_each(evlist, e) {
375 		if (perf_evsel__match2(evsel, e))
376 			return e;
377 	}
378 
379 	return NULL;
380 }
381 
382 static void perf_evlist__collapse_resort(struct perf_evlist *evlist)
383 {
384 	struct perf_evsel *evsel;
385 
386 	evlist__for_each(evlist, evsel) {
387 		struct hists *hists = evsel__hists(evsel);
388 
389 		hists__collapse_resort(hists, NULL);
390 	}
391 }
392 
393 static struct hist_entry*
394 get_pair_data(struct hist_entry *he, struct data__file *d)
395 {
396 	if (hist_entry__has_pairs(he)) {
397 		struct hist_entry *pair;
398 
399 		list_for_each_entry(pair, &he->pairs.head, pairs.node)
400 			if (pair->hists == d->hists)
401 				return pair;
402 	}
403 
404 	return NULL;
405 }
406 
407 static struct hist_entry*
408 get_pair_fmt(struct hist_entry *he, struct diff_hpp_fmt *dfmt)
409 {
410 	void *ptr = dfmt - dfmt->idx;
411 	struct data__file *d = container_of(ptr, struct data__file, fmt);
412 
413 	return get_pair_data(he, d);
414 }
415 
416 static void hists__baseline_only(struct hists *hists)
417 {
418 	struct rb_root *root;
419 	struct rb_node *next;
420 
421 	if (sort__need_collapse)
422 		root = &hists->entries_collapsed;
423 	else
424 		root = hists->entries_in;
425 
426 	next = rb_first(root);
427 	while (next != NULL) {
428 		struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in);
429 
430 		next = rb_next(&he->rb_node_in);
431 		if (!hist_entry__next_pair(he)) {
432 			rb_erase(&he->rb_node_in, root);
433 			hist_entry__free(he);
434 		}
435 	}
436 }
437 
438 static void hists__precompute(struct hists *hists)
439 {
440 	struct rb_root *root;
441 	struct rb_node *next;
442 
443 	if (sort__need_collapse)
444 		root = &hists->entries_collapsed;
445 	else
446 		root = hists->entries_in;
447 
448 	next = rb_first(root);
449 	while (next != NULL) {
450 		struct hist_entry *he, *pair;
451 
452 		he   = rb_entry(next, struct hist_entry, rb_node_in);
453 		next = rb_next(&he->rb_node_in);
454 
455 		pair = get_pair_data(he, &data__files[sort_compute]);
456 		if (!pair)
457 			continue;
458 
459 		switch (compute) {
460 		case COMPUTE_DELTA:
461 			compute_delta(he, pair);
462 			break;
463 		case COMPUTE_RATIO:
464 			compute_ratio(he, pair);
465 			break;
466 		case COMPUTE_WEIGHTED_DIFF:
467 			compute_wdiff(he, pair);
468 			break;
469 		default:
470 			BUG_ON(1);
471 		}
472 	}
473 }
474 
475 static int64_t cmp_doubles(double l, double r)
476 {
477 	if (l > r)
478 		return -1;
479 	else if (l < r)
480 		return 1;
481 	else
482 		return 0;
483 }
484 
485 static int64_t
486 __hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
487 			int c)
488 {
489 	switch (c) {
490 	case COMPUTE_DELTA:
491 	{
492 		double l = left->diff.period_ratio_delta;
493 		double r = right->diff.period_ratio_delta;
494 
495 		return cmp_doubles(l, r);
496 	}
497 	case COMPUTE_RATIO:
498 	{
499 		double l = left->diff.period_ratio;
500 		double r = right->diff.period_ratio;
501 
502 		return cmp_doubles(l, r);
503 	}
504 	case COMPUTE_WEIGHTED_DIFF:
505 	{
506 		s64 l = left->diff.wdiff;
507 		s64 r = right->diff.wdiff;
508 
509 		return r - l;
510 	}
511 	default:
512 		BUG_ON(1);
513 	}
514 
515 	return 0;
516 }
517 
518 static int64_t
519 hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
520 			int c)
521 {
522 	bool pairs_left  = hist_entry__has_pairs(left);
523 	bool pairs_right = hist_entry__has_pairs(right);
524 	struct hist_entry *p_right, *p_left;
525 
526 	if (!pairs_left && !pairs_right)
527 		return 0;
528 
529 	if (!pairs_left || !pairs_right)
530 		return pairs_left ? -1 : 1;
531 
532 	p_left  = get_pair_data(left,  &data__files[sort_compute]);
533 	p_right = get_pair_data(right, &data__files[sort_compute]);
534 
535 	if (!p_left && !p_right)
536 		return 0;
537 
538 	if (!p_left || !p_right)
539 		return p_left ? -1 : 1;
540 
541 	/*
542 	 * We have 2 entries of same kind, let's
543 	 * make the data comparison.
544 	 */
545 	return __hist_entry__cmp_compute(p_left, p_right, c);
546 }
547 
548 static int64_t
549 hist_entry__cmp_nop(struct hist_entry *left __maybe_unused,
550 		    struct hist_entry *right __maybe_unused)
551 {
552 	return 0;
553 }
554 
555 static int64_t
556 hist_entry__cmp_baseline(struct hist_entry *left, struct hist_entry *right)
557 {
558 	if (sort_compute)
559 		return 0;
560 
561 	if (left->stat.period == right->stat.period)
562 		return 0;
563 	return left->stat.period > right->stat.period ? 1 : -1;
564 }
565 
566 static int64_t
567 hist_entry__cmp_delta(struct hist_entry *left, struct hist_entry *right)
568 {
569 	return hist_entry__cmp_compute(right, left, COMPUTE_DELTA);
570 }
571 
572 static int64_t
573 hist_entry__cmp_ratio(struct hist_entry *left, struct hist_entry *right)
574 {
575 	return hist_entry__cmp_compute(right, left, COMPUTE_RATIO);
576 }
577 
578 static int64_t
579 hist_entry__cmp_wdiff(struct hist_entry *left, struct hist_entry *right)
580 {
581 	return hist_entry__cmp_compute(right, left, COMPUTE_WEIGHTED_DIFF);
582 }
583 
584 static void insert_hist_entry_by_compute(struct rb_root *root,
585 					 struct hist_entry *he,
586 					 int c)
587 {
588 	struct rb_node **p = &root->rb_node;
589 	struct rb_node *parent = NULL;
590 	struct hist_entry *iter;
591 
592 	while (*p != NULL) {
593 		parent = *p;
594 		iter = rb_entry(parent, struct hist_entry, rb_node);
595 		if (hist_entry__cmp_compute(he, iter, c) < 0)
596 			p = &(*p)->rb_left;
597 		else
598 			p = &(*p)->rb_right;
599 	}
600 
601 	rb_link_node(&he->rb_node, parent, p);
602 	rb_insert_color(&he->rb_node, root);
603 }
604 
605 static void hists__compute_resort(struct hists *hists)
606 {
607 	struct rb_root *root;
608 	struct rb_node *next;
609 
610 	if (sort__need_collapse)
611 		root = &hists->entries_collapsed;
612 	else
613 		root = hists->entries_in;
614 
615 	hists->entries = RB_ROOT;
616 	next = rb_first(root);
617 
618 	hists__reset_stats(hists);
619 	hists__reset_col_len(hists);
620 
621 	while (next != NULL) {
622 		struct hist_entry *he;
623 
624 		he = rb_entry(next, struct hist_entry, rb_node_in);
625 		next = rb_next(&he->rb_node_in);
626 
627 		insert_hist_entry_by_compute(&hists->entries, he, compute);
628 		hists__inc_stats(hists, he);
629 
630 		if (!he->filtered)
631 			hists__calc_col_len(hists, he);
632 	}
633 }
634 
635 static void hists__process(struct hists *hists)
636 {
637 	if (show_baseline_only)
638 		hists__baseline_only(hists);
639 
640 	if (sort_compute) {
641 		hists__precompute(hists);
642 		hists__compute_resort(hists);
643 	} else {
644 		hists__output_resort(hists, NULL);
645 	}
646 
647 	hists__fprintf(hists, true, 0, 0, 0, stdout);
648 }
649 
650 static void data__fprintf(void)
651 {
652 	struct data__file *d;
653 	int i;
654 
655 	fprintf(stdout, "# Data files:\n");
656 
657 	data__for_each_file(i, d)
658 		fprintf(stdout, "#  [%d] %s %s\n",
659 			d->idx, d->file.path,
660 			!d->idx ? "(Baseline)" : "");
661 
662 	fprintf(stdout, "#\n");
663 }
664 
665 static void data_process(void)
666 {
667 	struct perf_evlist *evlist_base = data__files[0].session->evlist;
668 	struct perf_evsel *evsel_base;
669 	bool first = true;
670 
671 	evlist__for_each(evlist_base, evsel_base) {
672 		struct hists *hists_base = evsel__hists(evsel_base);
673 		struct data__file *d;
674 		int i;
675 
676 		data__for_each_file_new(i, d) {
677 			struct perf_evlist *evlist = d->session->evlist;
678 			struct perf_evsel *evsel;
679 			struct hists *hists;
680 
681 			evsel = evsel_match(evsel_base, evlist);
682 			if (!evsel)
683 				continue;
684 
685 			hists = evsel__hists(evsel);
686 			d->hists = hists;
687 
688 			hists__match(hists_base, hists);
689 
690 			if (!show_baseline_only)
691 				hists__link(hists_base, hists);
692 		}
693 
694 		fprintf(stdout, "%s# Event '%s'\n#\n", first ? "" : "\n",
695 			perf_evsel__name(evsel_base));
696 
697 		first = false;
698 
699 		if (verbose || data__files_cnt > 2)
700 			data__fprintf();
701 
702 		hists__process(hists_base);
703 	}
704 }
705 
706 static void data__free(struct data__file *d)
707 {
708 	int col;
709 
710 	for (col = 0; col < PERF_HPP_DIFF__MAX_INDEX; col++) {
711 		struct diff_hpp_fmt *fmt = &d->fmt[col];
712 
713 		zfree(&fmt->header);
714 	}
715 }
716 
717 static int __cmd_diff(void)
718 {
719 	struct data__file *d;
720 	int ret = -EINVAL, i;
721 
722 	data__for_each_file(i, d) {
723 		d->session = perf_session__new(&d->file, false, &tool);
724 		if (!d->session) {
725 			pr_err("Failed to open %s\n", d->file.path);
726 			ret = -1;
727 			goto out_delete;
728 		}
729 
730 		ret = perf_session__process_events(d->session, &tool);
731 		if (ret) {
732 			pr_err("Failed to process %s\n", d->file.path);
733 			goto out_delete;
734 		}
735 
736 		perf_evlist__collapse_resort(d->session->evlist);
737 	}
738 
739 	data_process();
740 
741  out_delete:
742 	data__for_each_file(i, d) {
743 		if (d->session)
744 			perf_session__delete(d->session);
745 
746 		data__free(d);
747 	}
748 
749 	free(data__files);
750 	return ret;
751 }
752 
753 static const char * const diff_usage[] = {
754 	"perf diff [<options>] [old_file] [new_file]",
755 	NULL,
756 };
757 
758 static const struct option options[] = {
759 	OPT_INCR('v', "verbose", &verbose,
760 		    "be more verbose (show symbol address, etc)"),
761 	OPT_BOOLEAN('b', "baseline-only", &show_baseline_only,
762 		    "Show only items with match in baseline"),
763 	OPT_CALLBACK('c', "compute", &compute,
764 		     "delta,ratio,wdiff:w1,w2 (default delta)",
765 		     "Entries differential computation selection",
766 		     setup_compute),
767 	OPT_BOOLEAN('p', "period", &show_period,
768 		    "Show period values."),
769 	OPT_BOOLEAN('F', "formula", &show_formula,
770 		    "Show formula."),
771 	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
772 		    "dump raw trace in ASCII"),
773 	OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
774 	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
775 		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
776 	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
777 		   "only consider symbols in these dsos"),
778 	OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
779 		   "only consider symbols in these comms"),
780 	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
781 		   "only consider these symbols"),
782 	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
783 		   "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."
784 		   " Please refer the man page for the complete list."),
785 	OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
786 		   "separator for columns, no spaces will be added between "
787 		   "columns '.' is reserved."),
788 	OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
789 		    "Look for files with symbols relative to this directory"),
790 	OPT_UINTEGER('o', "order", &sort_compute, "Specify compute sorting."),
791 	OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
792 		     "How to display percentage of filtered entries", parse_filter_percentage),
793 	OPT_END()
794 };
795 
796 static double baseline_percent(struct hist_entry *he)
797 {
798 	u64 total = hists__total_period(he->hists);
799 
800 	return 100.0 * he->stat.period / total;
801 }
802 
803 static int hpp__color_baseline(struct perf_hpp_fmt *fmt,
804 			       struct perf_hpp *hpp, struct hist_entry *he)
805 {
806 	struct diff_hpp_fmt *dfmt =
807 		container_of(fmt, struct diff_hpp_fmt, fmt);
808 	double percent = baseline_percent(he);
809 	char pfmt[20] = " ";
810 
811 	if (!he->dummy) {
812 		scnprintf(pfmt, 20, "%%%d.2f%%%%", dfmt->header_width - 1);
813 		return percent_color_snprintf(hpp->buf, hpp->size,
814 					      pfmt, percent);
815 	} else
816 		return scnprintf(hpp->buf, hpp->size, "%*s",
817 				 dfmt->header_width, pfmt);
818 }
819 
820 static int hpp__entry_baseline(struct hist_entry *he, char *buf, size_t size)
821 {
822 	double percent = baseline_percent(he);
823 	const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%";
824 	int ret = 0;
825 
826 	if (!he->dummy)
827 		ret = scnprintf(buf, size, fmt, percent);
828 
829 	return ret;
830 }
831 
832 static int __hpp__color_compare(struct perf_hpp_fmt *fmt,
833 				struct perf_hpp *hpp, struct hist_entry *he,
834 				int comparison_method)
835 {
836 	struct diff_hpp_fmt *dfmt =
837 		container_of(fmt, struct diff_hpp_fmt, fmt);
838 	struct hist_entry *pair = get_pair_fmt(he, dfmt);
839 	double diff;
840 	s64 wdiff;
841 	char pfmt[20] = " ";
842 
843 	if (!pair)
844 		goto dummy_print;
845 
846 	switch (comparison_method) {
847 	case COMPUTE_DELTA:
848 		if (pair->diff.computed)
849 			diff = pair->diff.period_ratio_delta;
850 		else
851 			diff = compute_delta(he, pair);
852 
853 		if (fabs(diff) < 0.01)
854 			goto dummy_print;
855 		scnprintf(pfmt, 20, "%%%+d.2f%%%%", dfmt->header_width - 1);
856 		return percent_color_snprintf(hpp->buf, hpp->size,
857 					pfmt, diff);
858 	case COMPUTE_RATIO:
859 		if (he->dummy)
860 			goto dummy_print;
861 		if (pair->diff.computed)
862 			diff = pair->diff.period_ratio;
863 		else
864 			diff = compute_ratio(he, pair);
865 
866 		scnprintf(pfmt, 20, "%%%d.6f", dfmt->header_width);
867 		return value_color_snprintf(hpp->buf, hpp->size,
868 					pfmt, diff);
869 	case COMPUTE_WEIGHTED_DIFF:
870 		if (he->dummy)
871 			goto dummy_print;
872 		if (pair->diff.computed)
873 			wdiff = pair->diff.wdiff;
874 		else
875 			wdiff = compute_wdiff(he, pair);
876 
877 		scnprintf(pfmt, 20, "%%14ld", dfmt->header_width);
878 		return color_snprintf(hpp->buf, hpp->size,
879 				get_percent_color(wdiff),
880 				pfmt, wdiff);
881 	default:
882 		BUG_ON(1);
883 	}
884 dummy_print:
885 	return scnprintf(hpp->buf, hpp->size, "%*s",
886 			dfmt->header_width, pfmt);
887 }
888 
889 static int hpp__color_delta(struct perf_hpp_fmt *fmt,
890 			struct perf_hpp *hpp, struct hist_entry *he)
891 {
892 	return __hpp__color_compare(fmt, hpp, he, COMPUTE_DELTA);
893 }
894 
895 static int hpp__color_ratio(struct perf_hpp_fmt *fmt,
896 			struct perf_hpp *hpp, struct hist_entry *he)
897 {
898 	return __hpp__color_compare(fmt, hpp, he, COMPUTE_RATIO);
899 }
900 
901 static int hpp__color_wdiff(struct perf_hpp_fmt *fmt,
902 			struct perf_hpp *hpp, struct hist_entry *he)
903 {
904 	return __hpp__color_compare(fmt, hpp, he, COMPUTE_WEIGHTED_DIFF);
905 }
906 
907 static void
908 hpp__entry_unpair(struct hist_entry *he, int idx, char *buf, size_t size)
909 {
910 	switch (idx) {
911 	case PERF_HPP_DIFF__PERIOD_BASELINE:
912 		scnprintf(buf, size, "%" PRIu64, he->stat.period);
913 		break;
914 
915 	default:
916 		break;
917 	}
918 }
919 
920 static void
921 hpp__entry_pair(struct hist_entry *he, struct hist_entry *pair,
922 		int idx, char *buf, size_t size)
923 {
924 	double diff;
925 	double ratio;
926 	s64 wdiff;
927 
928 	switch (idx) {
929 	case PERF_HPP_DIFF__DELTA:
930 		if (pair->diff.computed)
931 			diff = pair->diff.period_ratio_delta;
932 		else
933 			diff = compute_delta(he, pair);
934 
935 		if (fabs(diff) >= 0.01)
936 			scnprintf(buf, size, "%+4.2F%%", diff);
937 		break;
938 
939 	case PERF_HPP_DIFF__RATIO:
940 		/* No point for ratio number if we are dummy.. */
941 		if (he->dummy)
942 			break;
943 
944 		if (pair->diff.computed)
945 			ratio = pair->diff.period_ratio;
946 		else
947 			ratio = compute_ratio(he, pair);
948 
949 		if (ratio > 0.0)
950 			scnprintf(buf, size, "%14.6F", ratio);
951 		break;
952 
953 	case PERF_HPP_DIFF__WEIGHTED_DIFF:
954 		/* No point for wdiff number if we are dummy.. */
955 		if (he->dummy)
956 			break;
957 
958 		if (pair->diff.computed)
959 			wdiff = pair->diff.wdiff;
960 		else
961 			wdiff = compute_wdiff(he, pair);
962 
963 		if (wdiff != 0)
964 			scnprintf(buf, size, "%14ld", wdiff);
965 		break;
966 
967 	case PERF_HPP_DIFF__FORMULA:
968 		formula_fprintf(he, pair, buf, size);
969 		break;
970 
971 	case PERF_HPP_DIFF__PERIOD:
972 		scnprintf(buf, size, "%" PRIu64, pair->stat.period);
973 		break;
974 
975 	default:
976 		BUG_ON(1);
977 	};
978 }
979 
980 static void
981 __hpp__entry_global(struct hist_entry *he, struct diff_hpp_fmt *dfmt,
982 		    char *buf, size_t size)
983 {
984 	struct hist_entry *pair = get_pair_fmt(he, dfmt);
985 	int idx = dfmt->idx;
986 
987 	/* baseline is special */
988 	if (idx == PERF_HPP_DIFF__BASELINE)
989 		hpp__entry_baseline(he, buf, size);
990 	else {
991 		if (pair)
992 			hpp__entry_pair(he, pair, idx, buf, size);
993 		else
994 			hpp__entry_unpair(he, idx, buf, size);
995 	}
996 }
997 
998 static int hpp__entry_global(struct perf_hpp_fmt *_fmt, struct perf_hpp *hpp,
999 			     struct hist_entry *he)
1000 {
1001 	struct diff_hpp_fmt *dfmt =
1002 		container_of(_fmt, struct diff_hpp_fmt, fmt);
1003 	char buf[MAX_COL_WIDTH] = " ";
1004 
1005 	__hpp__entry_global(he, dfmt, buf, MAX_COL_WIDTH);
1006 
1007 	if (symbol_conf.field_sep)
1008 		return scnprintf(hpp->buf, hpp->size, "%s", buf);
1009 	else
1010 		return scnprintf(hpp->buf, hpp->size, "%*s",
1011 				 dfmt->header_width, buf);
1012 }
1013 
1014 static int hpp__header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1015 		       struct perf_evsel *evsel __maybe_unused)
1016 {
1017 	struct diff_hpp_fmt *dfmt =
1018 		container_of(fmt, struct diff_hpp_fmt, fmt);
1019 
1020 	BUG_ON(!dfmt->header);
1021 	return scnprintf(hpp->buf, hpp->size, dfmt->header);
1022 }
1023 
1024 static int hpp__width(struct perf_hpp_fmt *fmt,
1025 		      struct perf_hpp *hpp __maybe_unused,
1026 		      struct perf_evsel *evsel __maybe_unused)
1027 {
1028 	struct diff_hpp_fmt *dfmt =
1029 		container_of(fmt, struct diff_hpp_fmt, fmt);
1030 
1031 	BUG_ON(dfmt->header_width <= 0);
1032 	return dfmt->header_width;
1033 }
1034 
1035 static void init_header(struct data__file *d, struct diff_hpp_fmt *dfmt)
1036 {
1037 #define MAX_HEADER_NAME 100
1038 	char buf_indent[MAX_HEADER_NAME];
1039 	char buf[MAX_HEADER_NAME];
1040 	const char *header = NULL;
1041 	int width = 0;
1042 
1043 	BUG_ON(dfmt->idx >= PERF_HPP_DIFF__MAX_INDEX);
1044 	header = columns[dfmt->idx].name;
1045 	width  = columns[dfmt->idx].width;
1046 
1047 	/* Only our defined HPP fmts should appear here. */
1048 	BUG_ON(!header);
1049 
1050 	if (data__files_cnt > 2)
1051 		scnprintf(buf, MAX_HEADER_NAME, "%s/%d", header, d->idx);
1052 
1053 #define NAME (data__files_cnt > 2 ? buf : header)
1054 	dfmt->header_width = width;
1055 	width = (int) strlen(NAME);
1056 	if (dfmt->header_width < width)
1057 		dfmt->header_width = width;
1058 
1059 	scnprintf(buf_indent, MAX_HEADER_NAME, "%*s",
1060 		  dfmt->header_width, NAME);
1061 
1062 	dfmt->header = strdup(buf_indent);
1063 #undef MAX_HEADER_NAME
1064 #undef NAME
1065 }
1066 
1067 static void data__hpp_register(struct data__file *d, int idx)
1068 {
1069 	struct diff_hpp_fmt *dfmt = &d->fmt[idx];
1070 	struct perf_hpp_fmt *fmt = &dfmt->fmt;
1071 
1072 	dfmt->idx = idx;
1073 
1074 	fmt->header = hpp__header;
1075 	fmt->width  = hpp__width;
1076 	fmt->entry  = hpp__entry_global;
1077 	fmt->cmp    = hist_entry__cmp_nop;
1078 	fmt->collapse = hist_entry__cmp_nop;
1079 
1080 	/* TODO more colors */
1081 	switch (idx) {
1082 	case PERF_HPP_DIFF__BASELINE:
1083 		fmt->color = hpp__color_baseline;
1084 		fmt->sort  = hist_entry__cmp_baseline;
1085 		break;
1086 	case PERF_HPP_DIFF__DELTA:
1087 		fmt->color = hpp__color_delta;
1088 		fmt->sort  = hist_entry__cmp_delta;
1089 		break;
1090 	case PERF_HPP_DIFF__RATIO:
1091 		fmt->color = hpp__color_ratio;
1092 		fmt->sort  = hist_entry__cmp_ratio;
1093 		break;
1094 	case PERF_HPP_DIFF__WEIGHTED_DIFF:
1095 		fmt->color = hpp__color_wdiff;
1096 		fmt->sort  = hist_entry__cmp_wdiff;
1097 		break;
1098 	default:
1099 		fmt->sort  = hist_entry__cmp_nop;
1100 		break;
1101 	}
1102 
1103 	init_header(d, dfmt);
1104 	perf_hpp__column_register(fmt);
1105 	perf_hpp__register_sort_field(fmt);
1106 }
1107 
1108 static void ui_init(void)
1109 {
1110 	struct data__file *d;
1111 	int i;
1112 
1113 	data__for_each_file(i, d) {
1114 
1115 		/*
1116 		 * Baseline or compute realted columns:
1117 		 *
1118 		 *   PERF_HPP_DIFF__BASELINE
1119 		 *   PERF_HPP_DIFF__DELTA
1120 		 *   PERF_HPP_DIFF__RATIO
1121 		 *   PERF_HPP_DIFF__WEIGHTED_DIFF
1122 		 */
1123 		data__hpp_register(d, i ? compute_2_hpp[compute] :
1124 					  PERF_HPP_DIFF__BASELINE);
1125 
1126 		/*
1127 		 * And the rest:
1128 		 *
1129 		 * PERF_HPP_DIFF__FORMULA
1130 		 * PERF_HPP_DIFF__PERIOD
1131 		 * PERF_HPP_DIFF__PERIOD_BASELINE
1132 		 */
1133 		if (show_formula && i)
1134 			data__hpp_register(d, PERF_HPP_DIFF__FORMULA);
1135 
1136 		if (show_period)
1137 			data__hpp_register(d, i ? PERF_HPP_DIFF__PERIOD :
1138 						  PERF_HPP_DIFF__PERIOD_BASELINE);
1139 	}
1140 }
1141 
1142 static int data_init(int argc, const char **argv)
1143 {
1144 	struct data__file *d;
1145 	static const char *defaults[] = {
1146 		"perf.data.old",
1147 		"perf.data",
1148 	};
1149 	bool use_default = true;
1150 	int i;
1151 
1152 	data__files_cnt = 2;
1153 
1154 	if (argc) {
1155 		if (argc == 1)
1156 			defaults[1] = argv[0];
1157 		else {
1158 			data__files_cnt = argc;
1159 			use_default = false;
1160 		}
1161 	} else if (perf_guest) {
1162 		defaults[0] = "perf.data.host";
1163 		defaults[1] = "perf.data.guest";
1164 	}
1165 
1166 	if (sort_compute >= (unsigned int) data__files_cnt) {
1167 		pr_err("Order option out of limit.\n");
1168 		return -EINVAL;
1169 	}
1170 
1171 	data__files = zalloc(sizeof(*data__files) * data__files_cnt);
1172 	if (!data__files)
1173 		return -ENOMEM;
1174 
1175 	data__for_each_file(i, d) {
1176 		struct perf_data_file *file = &d->file;
1177 
1178 		file->path  = use_default ? defaults[i] : argv[i];
1179 		file->mode  = PERF_DATA_MODE_READ,
1180 		file->force = force,
1181 
1182 		d->idx  = i;
1183 	}
1184 
1185 	return 0;
1186 }
1187 
1188 int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
1189 {
1190 	int ret = hists__init();
1191 
1192 	if (ret < 0)
1193 		return ret;
1194 
1195 	perf_config(perf_default_config, NULL);
1196 
1197 	argc = parse_options(argc, argv, options, diff_usage, 0);
1198 
1199 	if (symbol__init(NULL) < 0)
1200 		return -1;
1201 
1202 	if (data_init(argc, argv) < 0)
1203 		return -1;
1204 
1205 	ui_init();
1206 
1207 	sort__mode = SORT_MODE__DIFF;
1208 
1209 	if (setup_sorting() < 0)
1210 		usage_with_options(diff_usage, options);
1211 
1212 	setup_pager();
1213 
1214 	sort__setup_elide(NULL);
1215 
1216 	return __cmd_diff();
1217 }
1218