builtin-diff.c 22.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * builtin-diff.c
 *
 * Builtin diff command: Analyze two perf.data input files, look up and read
 * DSOs and symbol information, sort them and produce a diff.
 */
#include "builtin.h"

#include "util/debug.h"
#include "util/event.h"
#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 17 18
#include "util/sort.h"
#include "util/symbol.h"
#include "util/util.h"
19
#include "util/data.h"
20 21

#include <stdlib.h>
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
#include <math.h>

/* Diff command specific HPP columns. */
enum {
	PERF_HPP_DIFF__BASELINE,
	PERF_HPP_DIFF__PERIOD,
	PERF_HPP_DIFF__PERIOD_BASELINE,
	PERF_HPP_DIFF__DELTA,
	PERF_HPP_DIFF__RATIO,
	PERF_HPP_DIFF__WEIGHTED_DIFF,
	PERF_HPP_DIFF__FORMULA,

	PERF_HPP_DIFF__MAX_INDEX
};

struct diff_hpp_fmt {
	struct perf_hpp_fmt	 fmt;
	int			 idx;
	char			*header;
	int			 header_width;
};
43

44 45
struct data__file {
	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 53 54 55 56 57 58 59 60
};

static struct data__file *data__files;
static int data__files_cnt;

#define data__for_each_file_start(i, d, s)	\
	for (i = s, d = &data__files[s];	\
	     i < data__files_cnt;		\
	     i++, d = &data__files[i])

#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 64

static char diff__default_sort_order[] = "dso,symbol";
static bool force;
65
static bool show_period;
66
static bool show_formula;
67
static bool show_baseline_only;
68
static unsigned int sort_compute;
69

70 71 72
static s64 compute_wdiff_w1;
static s64 compute_wdiff_w2;

73 74 75
enum {
	COMPUTE_DELTA,
	COMPUTE_RATIO,
76
	COMPUTE_WEIGHTED_DIFF,
77 78 79 80 81 82
	COMPUTE_MAX,
};

const char *compute_names[COMPUTE_MAX] = {
	[COMPUTE_DELTA] = "delta",
	[COMPUTE_RATIO] = "ratio",
83
	[COMPUTE_WEIGHTED_DIFF] = "wdiff",
84 85 86 87
};

static int compute;

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
static int compute_2_hpp[COMPUTE_MAX] = {
	[COMPUTE_DELTA]		= PERF_HPP_DIFF__DELTA,
	[COMPUTE_RATIO]		= PERF_HPP_DIFF__RATIO,
	[COMPUTE_WEIGHTED_DIFF]	= PERF_HPP_DIFF__WEIGHTED_DIFF,
};

#define MAX_COL_WIDTH 70

static struct header_column {
	const char *name;
	int width;
} columns[PERF_HPP_DIFF__MAX_INDEX] = {
	[PERF_HPP_DIFF__BASELINE] = {
		.name  = "Baseline",
	},
	[PERF_HPP_DIFF__PERIOD] = {
		.name  = "Period",
		.width = 14,
	},
	[PERF_HPP_DIFF__PERIOD_BASELINE] = {
		.name  = "Base period",
		.width = 14,
	},
	[PERF_HPP_DIFF__DELTA] = {
		.name  = "Delta",
		.width = 7,
	},
	[PERF_HPP_DIFF__RATIO] = {
		.name  = "Ratio",
		.width = 14,
	},
	[PERF_HPP_DIFF__WEIGHTED_DIFF] = {
		.name  = "Weighted diff",
		.width = 14,
	},
	[PERF_HPP_DIFF__FORMULA] = {
		.name  = "Formula",
		.width = MAX_COL_WIDTH,
	}
};

129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
static int setup_compute_opt_wdiff(char *opt)
{
	char *w1_str = opt;
	char *w2_str;

	int ret = -EINVAL;

	if (!opt)
		goto out;

	w2_str = strchr(opt, ',');
	if (!w2_str)
		goto out;

	*w2_str++ = 0x0;
	if (!*w2_str)
		goto out;

	compute_wdiff_w1 = strtol(w1_str, NULL, 10);
	compute_wdiff_w2 = strtol(w2_str, NULL, 10);

	if (!compute_wdiff_w1 || !compute_wdiff_w2)
		goto out;

	pr_debug("compute wdiff w1(%" PRId64 ") w2(%" PRId64 ")\n",
		  compute_wdiff_w1, compute_wdiff_w2);

	ret = 0;

 out:
	if (ret)
		pr_err("Failed: wrong weight data, use 'wdiff:w1,w2'\n");

	return ret;
}

static int setup_compute_opt(char *opt)
{
	if (compute == COMPUTE_WEIGHTED_DIFF)
		return setup_compute_opt_wdiff(opt);

	if (opt) {
		pr_err("Failed: extra option specified '%s'", opt);
		return -EINVAL;
	}

	return 0;
}

178 179 180 181
static int setup_compute(const struct option *opt, const char *str,
			 int unset __maybe_unused)
{
	int *cp = (int *) opt->value;
182 183
	char *cstr = (char *) str;
	char buf[50];
184
	unsigned i;
185
	char *option;
186 187 188 189 190 191

	if (!str) {
		*cp = COMPUTE_DELTA;
		return 0;
	}

192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
	option = strchr(str, ':');
	if (option) {
		unsigned len = option++ - str;

		/*
		 * The str data are not writeable, so we need
		 * to use another buffer.
		 */

		/* No option value is longer. */
		if (len >= sizeof(buf))
			return -EINVAL;

		strncpy(buf, str, len);
		buf[len] = 0x0;
		cstr = buf;
	}

210
	for (i = 0; i < COMPUTE_MAX; i++)
211
		if (!strcmp(cstr, compute_names[i])) {
212
			*cp = i;
213
			return setup_compute_opt(option);
214 215 216
		}

	pr_err("Failed: '%s' is not computation method "
217
	       "(use 'delta','ratio' or 'wdiff')\n", str);
218 219 220
	return -EINVAL;
}

221
static double period_percent(struct hist_entry *he, u64 period)
222 223 224 225 226
{
	u64 total = he->hists->stats.total_period;
	return (period * 100.0) / total;
}

227
static double compute_delta(struct hist_entry *he, struct hist_entry *pair)
228
{
229 230
	double old_percent = period_percent(he, he->stat.period);
	double new_percent = period_percent(pair, pair->stat.period);
231

232 233 234
	pair->diff.period_ratio_delta = new_percent - old_percent;
	pair->diff.computed = true;
	return pair->diff.period_ratio_delta;
235 236
}

237
static double compute_ratio(struct hist_entry *he, struct hist_entry *pair)
238
{
239 240
	double old_period = he->stat.period ?: 1;
	double new_period = pair->stat.period;
241

242 243 244
	pair->diff.computed = true;
	pair->diff.period_ratio = new_period / old_period;
	return pair->diff.period_ratio;
245 246
}

247
static s64 compute_wdiff(struct hist_entry *he, struct hist_entry *pair)
248
{
249 250
	u64 old_period = he->stat.period;
	u64 new_period = pair->stat.period;
251

252 253 254
	pair->diff.computed = true;
	pair->diff.wdiff = new_period * compute_wdiff_w2 -
			   old_period * compute_wdiff_w1;
255

256
	return pair->diff.wdiff;
257 258
}

259 260
static int formula_delta(struct hist_entry *he, struct hist_entry *pair,
			 char *buf, size_t size)
261 262 263 264
{
	return scnprintf(buf, size,
			 "(%" PRIu64 " * 100 / %" PRIu64 ") - "
			 "(%" PRIu64 " * 100 / %" PRIu64 ")",
265 266
			  pair->stat.period, pair->hists->stats.total_period,
			  he->stat.period, he->hists->stats.total_period);
267 268
}

269 270
static int formula_ratio(struct hist_entry *he, struct hist_entry *pair,
			 char *buf, size_t size)
271
{
272 273
	double old_period = he->stat.period;
	double new_period = pair->stat.period;
274 275 276 277

	return scnprintf(buf, size, "%.0F / %.0F", new_period, old_period);
}

278 279
static int formula_wdiff(struct hist_entry *he, struct hist_entry *pair,
			 char *buf, size_t size)
280
{
281 282
	u64 old_period = he->stat.period;
	u64 new_period = pair->stat.period;
283 284 285 286 287 288

	return scnprintf(buf, size,
		  "(%" PRIu64 " * " "%" PRId64 ") - (%" PRIu64 " * " "%" PRId64 ")",
		  new_period, compute_wdiff_w2, old_period, compute_wdiff_w1);
}

289 290
static int formula_fprintf(struct hist_entry *he, struct hist_entry *pair,
			   char *buf, size_t size)
291 292 293
{
	switch (compute) {
	case COMPUTE_DELTA:
294
		return formula_delta(he, pair, buf, size);
295
	case COMPUTE_RATIO:
296
		return formula_ratio(he, pair, buf, size);
297
	case COMPUTE_WEIGHTED_DIFF:
298
		return formula_wdiff(he, pair, buf, size);
299 300 301 302 303 304 305
	default:
		BUG_ON(1);
	}

	return -1;
}

306
static int hists__add_entry(struct hists *self,
307
			    struct addr_location *al, u64 period,
308
			    u64 weight, u64 transaction)
309
{
310 311
	if (__hists__add_entry(self, al, NULL, period, weight, transaction)
	    != NULL)
312 313
		return 0;
	return -ENOMEM;
314 315
}

316
static int diff__process_sample_event(struct perf_tool *tool __maybe_unused,
317
				      union perf_event *event,
318
				      struct perf_sample *sample,
319
				      struct perf_evsel *evsel,
320
				      struct machine *machine)
321 322 323
{
	struct addr_location al;

324
	if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
325 326 327 328 329
		pr_warning("problem processing %d event, skipping it.\n",
			   event->header.type);
		return -1;
	}

330
	if (al.filtered)
331 332
		return 0;

333 334
	if (hists__add_entry(&evsel->hists, &al, sample->period,
			     sample->weight, sample->transaction)) {
335
		pr_warning("problem incrementing symbol period, skipping event\n");
336 337 338
		return -1;
	}

339
	evsel->hists.stats.total_period += sample->period;
340 341 342
	return 0;
}

343 344 345 346
static struct perf_tool tool = {
	.sample	= diff__process_sample_event,
	.mmap	= perf_event__process_mmap,
	.comm	= perf_event__process_comm,
347 348
	.exit	= perf_event__process_exit,
	.fork	= perf_event__process_fork,
349 350 351
	.lost	= perf_event__process_lost,
	.ordered_samples = true,
	.ordering_requires_timestamps = true,
352 353
};

354 355 356 357 358 359 360 361 362 363 364 365
static struct perf_evsel *evsel_match(struct perf_evsel *evsel,
				      struct perf_evlist *evlist)
{
	struct perf_evsel *e;

	list_for_each_entry(e, &evlist->entries, node)
		if (perf_evsel__match2(evsel, e))
			return e;

	return NULL;
}

366
static void perf_evlist__collapse_resort(struct perf_evlist *evlist)
367 368 369 370 371 372
{
	struct perf_evsel *evsel;

	list_for_each_entry(evsel, &evlist->entries, node) {
		struct hists *hists = &evsel->hists;

373
		hists__collapse_resort(hists);
374 375 376
	}
}

377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
static struct hist_entry*
get_pair_data(struct hist_entry *he, struct data__file *d)
{
	if (hist_entry__has_pairs(he)) {
		struct hist_entry *pair;

		list_for_each_entry(pair, &he->pairs.head, pairs.node)
			if (pair->hists == d->hists)
				return pair;
	}

	return NULL;
}

static struct hist_entry*
get_pair_fmt(struct hist_entry *he, struct diff_hpp_fmt *dfmt)
{
	void *ptr = dfmt - dfmt->idx;
	struct data__file *d = container_of(ptr, struct data__file, fmt);

	return get_pair_data(he, d);
}

400 401
static void hists__baseline_only(struct hists *hists)
{
402 403 404 405 406 407 408
	struct rb_root *root;
	struct rb_node *next;

	if (sort__need_collapse)
		root = &hists->entries_collapsed;
	else
		root = hists->entries_in;
409

410
	next = rb_first(root);
411
	while (next != NULL) {
412
		struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in);
413

414
		next = rb_next(&he->rb_node_in);
415
		if (!hist_entry__next_pair(he)) {
416
			rb_erase(&he->rb_node_in, root);
417 418 419 420 421
			hist_entry__free(he);
		}
	}
}

422 423
static void hists__precompute(struct hists *hists)
{
424 425 426 427 428 429 430
	struct rb_root *root;
	struct rb_node *next;

	if (sort__need_collapse)
		root = &hists->entries_collapsed;
	else
		root = hists->entries_in;
431

432
	next = rb_first(root);
433
	while (next != NULL) {
434
		struct hist_entry *he, *pair;
435

436
		he   = rb_entry(next, struct hist_entry, rb_node_in);
437
		next = rb_next(&he->rb_node_in);
438 439

		pair = get_pair_data(he, &data__files[sort_compute]);
440 441
		if (!pair)
			continue;
442 443 444

		switch (compute) {
		case COMPUTE_DELTA:
445
			compute_delta(he, pair);
446 447
			break;
		case COMPUTE_RATIO:
448
			compute_ratio(he, pair);
449
			break;
450
		case COMPUTE_WEIGHTED_DIFF:
451
			compute_wdiff(he, pair);
452
			break;
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
		default:
			BUG_ON(1);
		}
	}
}

static int64_t cmp_doubles(double l, double r)
{
	if (l > r)
		return -1;
	else if (l < r)
		return 1;
	else
		return 0;
}

static int64_t
470
__hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
			int c)
{
	switch (c) {
	case COMPUTE_DELTA:
	{
		double l = left->diff.period_ratio_delta;
		double r = right->diff.period_ratio_delta;

		return cmp_doubles(l, r);
	}
	case COMPUTE_RATIO:
	{
		double l = left->diff.period_ratio;
		double r = right->diff.period_ratio;

		return cmp_doubles(l, r);
	}
488 489 490 491 492 493 494
	case COMPUTE_WEIGHTED_DIFF:
	{
		s64 l = left->diff.wdiff;
		s64 r = right->diff.wdiff;

		return r - l;
	}
495 496 497 498 499 500 501
	default:
		BUG_ON(1);
	}

	return 0;
}

502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
static int64_t
hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
			int c)
{
	bool pairs_left  = hist_entry__has_pairs(left);
	bool pairs_right = hist_entry__has_pairs(right);
	struct hist_entry *p_right, *p_left;

	if (!pairs_left && !pairs_right)
		return 0;

	if (!pairs_left || !pairs_right)
		return pairs_left ? -1 : 1;

	p_left  = get_pair_data(left,  &data__files[sort_compute]);
	p_right = get_pair_data(right, &data__files[sort_compute]);

	if (!p_left && !p_right)
		return 0;

	if (!p_left || !p_right)
		return p_left ? -1 : 1;

	/*
	 * We have 2 entries of same kind, let's
	 * make the data comparison.
	 */
	return __hist_entry__cmp_compute(p_left, p_right, c);
}

532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
static void insert_hist_entry_by_compute(struct rb_root *root,
					 struct hist_entry *he,
					 int c)
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct hist_entry *iter;

	while (*p != NULL) {
		parent = *p;
		iter = rb_entry(parent, struct hist_entry, rb_node);
		if (hist_entry__cmp_compute(he, iter, c) < 0)
			p = &(*p)->rb_left;
		else
			p = &(*p)->rb_right;
	}

	rb_link_node(&he->rb_node, parent, p);
	rb_insert_color(&he->rb_node, root);
}

static void hists__compute_resort(struct hists *hists)
{
555 556 557 558 559 560 561 562 563 564 565 566 567 568
	struct rb_root *root;
	struct rb_node *next;

	if (sort__need_collapse)
		root = &hists->entries_collapsed;
	else
		root = hists->entries_in;

	hists->entries = RB_ROOT;
	next = rb_first(root);

	hists->nr_entries = 0;
	hists->stats.total_period = 0;
	hists__reset_col_len(hists);
569 570

	while (next != NULL) {
571
		struct hist_entry *he;
572

573 574
		he = rb_entry(next, struct hist_entry, rb_node_in);
		next = rb_next(&he->rb_node_in);
575

576 577
		insert_hist_entry_by_compute(&hists->entries, he, compute);
		hists__inc_nr_entries(hists, he);
578 579 580
	}
}

581
static void hists__process(struct hists *hists)
582 583
{
	if (show_baseline_only)
584
		hists__baseline_only(hists);
585

586
	if (sort_compute) {
587 588
		hists__precompute(hists);
		hists__compute_resort(hists);
589
	} else {
590
		hists__output_resort(hists);
591 592
	}

593
	hists__fprintf(hists, true, 0, 0, 0, stdout);
594 595
}

596 597 598 599 600 601 602 603 604
static void data__fprintf(void)
{
	struct data__file *d;
	int i;

	fprintf(stdout, "# Data files:\n");

	data__for_each_file(i, d)
		fprintf(stdout, "#  [%d] %s %s\n",
605
			d->idx, d->file.path,
606 607 608 609 610
			!d->idx ? "(Baseline)" : "");

	fprintf(stdout, "#\n");
}

611
static void data_process(void)
612
{
613 614
	struct perf_evlist *evlist_base = data__files[0].session->evlist;
	struct perf_evsel *evsel_base;
615
	bool first = true;
616

617 618 619
	list_for_each_entry(evsel_base, &evlist_base->entries, node) {
		struct data__file *d;
		int i;
620

621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
		data__for_each_file_new(i, d) {
			struct perf_evlist *evlist = d->session->evlist;
			struct perf_evsel *evsel;

			evsel = evsel_match(evsel_base, evlist);
			if (!evsel)
				continue;

			d->hists = &evsel->hists;

			hists__match(&evsel_base->hists, &evsel->hists);

			if (!show_baseline_only)
				hists__link(&evsel_base->hists,
					    &evsel->hists);
		}
637

638
		fprintf(stdout, "%s# Event '%s'\n#\n", first ? "" : "\n",
639
			perf_evsel__name(evsel_base));
640

641
		first = false;
642

643
		if (verbose || data__files_cnt > 2)
644 645
			data__fprintf();

646
		hists__process(&evsel_base->hists);
647 648
	}
}
649

650 651 652 653 654 655 656 657 658 659 660
static void data__free(struct data__file *d)
{
	int col;

	for (col = 0; col < PERF_HPP_DIFF__MAX_INDEX; col++) {
		struct diff_hpp_fmt *fmt = &d->fmt[col];

		free(fmt->header);
	}
}

661 662 663 664 665 666
static int __cmd_diff(void)
{
	struct data__file *d;
	int ret = -EINVAL, i;

	data__for_each_file(i, d) {
667
		d->session = perf_session__new(&d->file, false, &tool);
668
		if (!d->session) {
669
			pr_err("Failed to open %s\n", d->file.path);
670 671 672
			ret = -ENOMEM;
			goto out_delete;
		}
673

674 675
		ret = perf_session__process_events(d->session, &tool);
		if (ret) {
676
			pr_err("Failed to process %s\n", d->file.path);
677 678
			goto out_delete;
		}
679

680 681 682 683
		perf_evlist__collapse_resort(d->session->evlist);
	}

	data_process();
684

685 686 687 688
 out_delete:
	data__for_each_file(i, d) {
		if (d->session)
			perf_session__delete(d->session);
689 690

		data__free(d);
691
	}
692

693
	free(data__files);
694 695 696
	return ret;
}

697
static const char * const diff_usage[] = {
698
	"perf diff [<options>] [old_file] [new_file]",
699
	NULL,
700 701 702
};

static const struct option options[] = {
703
	OPT_INCR('v', "verbose", &verbose,
704
		    "be more verbose (show symbol address, etc)"),
705 706
	OPT_BOOLEAN('b', "baseline-only", &show_baseline_only,
		    "Show only items with match in baseline"),
707 708
	OPT_CALLBACK('c', "compute", &compute,
		     "delta,ratio,wdiff:w1,w2 (default delta)",
709 710
		     "Entries differential computation selection",
		     setup_compute),
711 712
	OPT_BOOLEAN('p', "period", &show_period,
		    "Show period values."),
713 714
	OPT_BOOLEAN('F', "formula", &show_formula,
		    "Show formula."),
715 716 717 718 719
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
	OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
720 721 722 723 724 725
	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
		   "only consider symbols in these dsos"),
	OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
		   "only consider symbols in these comms"),
	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
		   "only consider these symbols"),
726 727 728 729 730
	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
		   "sort by key(s): pid, comm, dso, symbol, parent"),
	OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
		   "separator for columns, no spaces will be added between "
		   "columns '.' is reserved."),
731 732
	OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
		    "Look for files with symbols relative to this directory"),
733
	OPT_UINTEGER('o', "order", &sort_compute, "Specify compute sorting."),
734 735 736
	OPT_END()
};

737
static double baseline_percent(struct hist_entry *he)
738
{
739 740 741
	struct hists *hists = he->hists;
	return 100.0 * he->stat.period / hists->stats.total_period;
}
742

743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
static int hpp__color_baseline(struct perf_hpp_fmt *fmt,
			       struct perf_hpp *hpp, struct hist_entry *he)
{
	struct diff_hpp_fmt *dfmt =
		container_of(fmt, struct diff_hpp_fmt, fmt);
	double percent = baseline_percent(he);
	char pfmt[20] = " ";

	if (!he->dummy) {
		scnprintf(pfmt, 20, "%%%d.2f%%%%", dfmt->header_width - 1);
		return percent_color_snprintf(hpp->buf, hpp->size,
					      pfmt, percent);
	} else
		return scnprintf(hpp->buf, hpp->size, "%*s",
				 dfmt->header_width, pfmt);
}

static int hpp__entry_baseline(struct hist_entry *he, char *buf, size_t size)
{
	double percent = baseline_percent(he);
	const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%";
	int ret = 0;

	if (!he->dummy)
		ret = scnprintf(buf, size, fmt, percent);

	return ret;
}

static void
hpp__entry_unpair(struct hist_entry *he, int idx, char *buf, size_t size)
{
	switch (idx) {
	case PERF_HPP_DIFF__PERIOD_BASELINE:
		scnprintf(buf, size, "%" PRIu64, he->stat.period);
778
		break;
779 780

	default:
781
		break;
782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
	}
}

static void
hpp__entry_pair(struct hist_entry *he, struct hist_entry *pair,
		int idx, char *buf, size_t size)
{
	double diff;
	double ratio;
	s64 wdiff;

	switch (idx) {
	case PERF_HPP_DIFF__DELTA:
		if (pair->diff.computed)
			diff = pair->diff.period_ratio_delta;
		else
798
			diff = compute_delta(he, pair);
799 800 801 802 803 804 805 806 807 808 809 810 811

		if (fabs(diff) >= 0.01)
			scnprintf(buf, size, "%+4.2F%%", diff);
		break;

	case PERF_HPP_DIFF__RATIO:
		/* No point for ratio number if we are dummy.. */
		if (he->dummy)
			break;

		if (pair->diff.computed)
			ratio = pair->diff.period_ratio;
		else
812
			ratio = compute_ratio(he, pair);
813 814 815 816 817 818 819 820 821 822 823 824 825

		if (ratio > 0.0)
			scnprintf(buf, size, "%14.6F", ratio);
		break;

	case PERF_HPP_DIFF__WEIGHTED_DIFF:
		/* No point for wdiff number if we are dummy.. */
		if (he->dummy)
			break;

		if (pair->diff.computed)
			wdiff = pair->diff.wdiff;
		else
826
			wdiff = compute_wdiff(he, pair);
827 828 829 830 831 832

		if (wdiff != 0)
			scnprintf(buf, size, "%14ld", wdiff);
		break;

	case PERF_HPP_DIFF__FORMULA:
833
		formula_fprintf(he, pair, buf, size);
834
		break;
835 836 837 838 839

	case PERF_HPP_DIFF__PERIOD:
		scnprintf(buf, size, "%" PRIu64, pair->stat.period);
		break;

840 841 842
	default:
		BUG_ON(1);
	};
843 844 845
}

static void
846 847
__hpp__entry_global(struct hist_entry *he, struct diff_hpp_fmt *dfmt,
		    char *buf, size_t size)
848
{
849
	struct hist_entry *pair = get_pair_fmt(he, dfmt);
850
	int idx = dfmt->idx;
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869

	/* baseline is special */
	if (idx == PERF_HPP_DIFF__BASELINE)
		hpp__entry_baseline(he, buf, size);
	else {
		if (pair)
			hpp__entry_pair(he, pair, idx, buf, size);
		else
			hpp__entry_unpair(he, idx, buf, size);
	}
}

static int hpp__entry_global(struct perf_hpp_fmt *_fmt, struct perf_hpp *hpp,
			     struct hist_entry *he)
{
	struct diff_hpp_fmt *dfmt =
		container_of(_fmt, struct diff_hpp_fmt, fmt);
	char buf[MAX_COL_WIDTH] = " ";

870
	__hpp__entry_global(he, dfmt, buf, MAX_COL_WIDTH);
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898

	if (symbol_conf.field_sep)
		return scnprintf(hpp->buf, hpp->size, "%s", buf);
	else
		return scnprintf(hpp->buf, hpp->size, "%*s",
				 dfmt->header_width, buf);
}

static int hpp__header(struct perf_hpp_fmt *fmt,
		       struct perf_hpp *hpp)
{
	struct diff_hpp_fmt *dfmt =
		container_of(fmt, struct diff_hpp_fmt, fmt);

	BUG_ON(!dfmt->header);
	return scnprintf(hpp->buf, hpp->size, dfmt->header);
}

static int hpp__width(struct perf_hpp_fmt *fmt,
		      struct perf_hpp *hpp __maybe_unused)
{
	struct diff_hpp_fmt *dfmt =
		container_of(fmt, struct diff_hpp_fmt, fmt);

	BUG_ON(dfmt->header_width <= 0);
	return dfmt->header_width;
}

899
static void init_header(struct data__file *d, struct diff_hpp_fmt *dfmt)
900 901 902 903 904 905 906 907 908 909 910 911 912 913
{
#define MAX_HEADER_NAME 100
	char buf_indent[MAX_HEADER_NAME];
	char buf[MAX_HEADER_NAME];
	const char *header = NULL;
	int width = 0;

	BUG_ON(dfmt->idx >= PERF_HPP_DIFF__MAX_INDEX);
	header = columns[dfmt->idx].name;
	width  = columns[dfmt->idx].width;

	/* Only our defined HPP fmts should appear here. */
	BUG_ON(!header);

914 915 916
	if (data__files_cnt > 2)
		scnprintf(buf, MAX_HEADER_NAME, "%s/%d", header, d->idx);

917 918 919 920 921 922 923 924 925 926 927 928 929 930
#define NAME (data__files_cnt > 2 ? buf : header)
	dfmt->header_width = width;
	width = (int) strlen(NAME);
	if (dfmt->header_width < width)
		dfmt->header_width = width;

	scnprintf(buf_indent, MAX_HEADER_NAME, "%*s",
		  dfmt->header_width, NAME);

	dfmt->header = strdup(buf_indent);
#undef MAX_HEADER_NAME
#undef NAME
}

931
static void data__hpp_register(struct data__file *d, int idx)
932
{
933 934 935 936 937 938 939 940 941 942 943 944
	struct diff_hpp_fmt *dfmt = &d->fmt[idx];
	struct perf_hpp_fmt *fmt = &dfmt->fmt;

	dfmt->idx = idx;

	fmt->header = hpp__header;
	fmt->width  = hpp__width;
	fmt->entry  = hpp__entry_global;

	/* TODO more colors */
	if (idx == PERF_HPP_DIFF__BASELINE)
		fmt->color = hpp__color_baseline;
945

946
	init_header(d, dfmt);
947
	perf_hpp__column_register(fmt);
948 949 950 951
}

static void ui_init(void)
{
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
	struct data__file *d;
	int i;

	data__for_each_file(i, d) {

		/*
		 * Baseline or compute realted columns:
		 *
		 *   PERF_HPP_DIFF__BASELINE
		 *   PERF_HPP_DIFF__DELTA
		 *   PERF_HPP_DIFF__RATIO
		 *   PERF_HPP_DIFF__WEIGHTED_DIFF
		 */
		data__hpp_register(d, i ? compute_2_hpp[compute] :
					  PERF_HPP_DIFF__BASELINE);
967

968 969 970 971 972 973 974 975 976
		/*
		 * And the rest:
		 *
		 * PERF_HPP_DIFF__FORMULA
		 * PERF_HPP_DIFF__PERIOD
		 * PERF_HPP_DIFF__PERIOD_BASELINE
		 */
		if (show_formula && i)
			data__hpp_register(d, PERF_HPP_DIFF__FORMULA);
977

978 979 980
		if (show_period)
			data__hpp_register(d, i ? PERF_HPP_DIFF__PERIOD :
						  PERF_HPP_DIFF__PERIOD_BASELINE);
981
	}
982 983
}

984
static int data_init(int argc, const char **argv)
985
{
986 987 988 989 990
	struct data__file *d;
	static const char *defaults[] = {
		"perf.data.old",
		"perf.data",
	};
991
	bool use_default = true;
992 993 994 995
	int i;

	data__files_cnt = 2;

996
	if (argc) {
997
		if (argc == 1)
998
			defaults[1] = argv[0];
999 1000 1001 1002
		else {
			data__files_cnt = argc;
			use_default = false;
		}
1003 1004
	} else if (symbol_conf.default_guest_vmlinux_name ||
		   symbol_conf.default_guest_kallsyms) {
1005 1006
		defaults[0] = "perf.data.host";
		defaults[1] = "perf.data.guest";
1007 1008
	}

1009 1010 1011 1012 1013
	if (sort_compute >= (unsigned int) data__files_cnt) {
		pr_err("Order option out of limit.\n");
		return -EINVAL;
	}

1014 1015 1016 1017 1018
	data__files = zalloc(sizeof(*data__files) * data__files_cnt);
	if (!data__files)
		return -ENOMEM;

	data__for_each_file(i, d) {
1019 1020 1021 1022 1023 1024
		struct perf_data_file *file = &d->file;

		file->path  = use_default ? defaults[i] : argv[i];
		file->mode  = PERF_DATA_MODE_READ,
		file->force = force,

1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
		d->idx  = i;
	}

	return 0;
}

int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
{
	sort_order = diff__default_sort_order;
	argc = parse_options(argc, argv, options, diff_usage, 0);

1036 1037 1038
	if (symbol__init() < 0)
		return -1;

1039 1040 1041
	if (data_init(argc, argv) < 0)
		return -1;

1042 1043
	ui_init();

1044 1045 1046
	if (setup_sorting() < 0)
		usage_with_options(diff_usage, options);

1047
	setup_pager();
1048

1049
	sort__setup_elide(NULL);
1050

1051 1052
	return __cmd_diff();
}