builtin-diff.c 21.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 19 20
#include "util/sort.h"
#include "util/symbol.h"
#include "util/util.h"

#include <stdlib.h>
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
#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;
};
42

43 44 45 46
struct data__file {
	struct perf_session	*session;
	const char		*file;
	int			 idx;
47
	struct hists		*hists;
48
	struct diff_hpp_fmt	 fmt[PERF_HPP_DIFF__MAX_INDEX];
49 50 51 52 53 54 55 56 57 58 59
};

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)
60
#define data__for_each_file_new(i, d) data__for_each_file_start(i, d, 1)
61 62 63

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

69 70 71
static s64 compute_wdiff_w1;
static s64 compute_wdiff_w2;

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

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

static int compute;

87 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
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,
	}
};

128 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
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;
}

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

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

191 192
	if (*str == '+') {
		sort_compute = true;
193
		cstr = (char *) ++str;
194 195 196 197
		if (!*str)
			return 0;
	}

198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
	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;
	}

216
	for (i = 0; i < COMPUTE_MAX; i++)
217
		if (!strcmp(cstr, compute_names[i])) {
218
			*cp = i;
219
			return setup_compute_opt(option);
220 221 222
		}

	pr_err("Failed: '%s' is not computation method "
223
	       "(use 'delta','ratio' or 'wdiff')\n", str);
224 225 226
	return -EINVAL;
}

227
double perf_diff__period_percent(struct hist_entry *he, u64 period)
228 229 230 231 232
{
	u64 total = he->hists->stats.total_period;
	return (period * 100.0) / total;
}

233
double perf_diff__compute_delta(struct hist_entry *he, struct hist_entry *pair)
234
{
235 236
	double old_percent = perf_diff__period_percent(he, he->stat.period);
	double new_percent = perf_diff__period_percent(pair, pair->stat.period);
237

238 239 240
	pair->diff.period_ratio_delta = new_percent - old_percent;
	pair->diff.computed = true;
	return pair->diff.period_ratio_delta;
241 242
}

243
double perf_diff__compute_ratio(struct hist_entry *he, struct hist_entry *pair)
244
{
245 246
	double old_period = he->stat.period ?: 1;
	double new_period = pair->stat.period;
247

248 249 250
	pair->diff.computed = true;
	pair->diff.period_ratio = new_period / old_period;
	return pair->diff.period_ratio;
251 252
}

253
s64 perf_diff__compute_wdiff(struct hist_entry *he, struct hist_entry *pair)
254
{
255 256
	u64 old_period = he->stat.period;
	u64 new_period = pair->stat.period;
257

258 259 260
	pair->diff.computed = true;
	pair->diff.wdiff = new_period * compute_wdiff_w2 -
			   old_period * compute_wdiff_w1;
261

262
	return pair->diff.wdiff;
263 264
}

265 266
static int formula_delta(struct hist_entry *he, struct hist_entry *pair,
			 char *buf, size_t size)
267 268 269 270
{
	return scnprintf(buf, size,
			 "(%" PRIu64 " * 100 / %" PRIu64 ") - "
			 "(%" PRIu64 " * 100 / %" PRIu64 ")",
271 272
			  pair->stat.period, pair->hists->stats.total_period,
			  he->stat.period, he->hists->stats.total_period);
273 274
}

275 276
static int formula_ratio(struct hist_entry *he, struct hist_entry *pair,
			 char *buf, size_t size)
277
{
278 279
	double old_period = he->stat.period;
	double new_period = pair->stat.period;
280 281 282 283

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

284 285
static int formula_wdiff(struct hist_entry *he, struct hist_entry *pair,
			 char *buf, size_t size)
286
{
287 288
	u64 old_period = he->stat.period;
	u64 new_period = pair->stat.period;
289 290 291 292 293 294

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

295 296
int perf_diff__formula(struct hist_entry *he, struct hist_entry *pair,
		       char *buf, size_t size)
297 298 299
{
	switch (compute) {
	case COMPUTE_DELTA:
300
		return formula_delta(he, pair, buf, size);
301
	case COMPUTE_RATIO:
302
		return formula_ratio(he, pair, buf, size);
303
	case COMPUTE_WEIGHTED_DIFF:
304
		return formula_wdiff(he, pair, buf, size);
305 306 307 308 309 310 311
	default:
		BUG_ON(1);
	}

	return -1;
}

312
static int hists__add_entry(struct hists *self,
313 314
			    struct addr_location *al, u64 period,
			    u64 weight)
315
{
316
	if (__hists__add_entry(self, al, NULL, period, weight) != NULL)
317 318
		return 0;
	return -ENOMEM;
319 320
}

321
static int diff__process_sample_event(struct perf_tool *tool __maybe_unused,
322
				      union perf_event *event,
323
				      struct perf_sample *sample,
324
				      struct perf_evsel *evsel,
325
				      struct machine *machine)
326 327 328
{
	struct addr_location al;

329
	if (perf_event__preprocess_sample(event, machine, &al, sample, NULL) < 0) {
330 331 332 333 334
		pr_warning("problem processing %d event, skipping it.\n",
			   event->header.type);
		return -1;
	}

335
	if (al.filtered)
336 337
		return 0;

338
	if (hists__add_entry(&evsel->hists, &al, sample->period, sample->weight)) {
339
		pr_warning("problem incrementing symbol period, skipping event\n");
340 341 342
		return -1;
	}

343
	evsel->hists.stats.total_period += sample->period;
344 345 346
	return 0;
}

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

358 359 360 361 362 363 364 365 366 367 368 369
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;
}

370
static void perf_evlist__collapse_resort(struct perf_evlist *evlist)
371 372 373 374 375 376
{
	struct perf_evsel *evsel;

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

377
		hists__collapse_resort(hists);
378 379 380
	}
}

381 382
static void hists__baseline_only(struct hists *hists)
{
383 384 385 386 387 388 389
	struct rb_root *root;
	struct rb_node *next;

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

391
	next = rb_first(root);
392
	while (next != NULL) {
393
		struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in);
394

395
		next = rb_next(&he->rb_node_in);
396
		if (!hist_entry__next_pair(he)) {
397
			rb_erase(&he->rb_node_in, root);
398 399 400 401 402
			hist_entry__free(he);
		}
	}
}

403 404
static void hists__precompute(struct hists *hists)
{
405 406 407 408 409 410 411
	struct rb_root *root;
	struct rb_node *next;

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

413
	next = rb_first(root);
414
	while (next != NULL) {
415
		struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in);
416
		struct hist_entry *pair = hist_entry__next_pair(he);
417

418
		next = rb_next(&he->rb_node_in);
419 420
		if (!pair)
			continue;
421 422 423

		switch (compute) {
		case COMPUTE_DELTA:
424
			perf_diff__compute_delta(he, pair);
425 426
			break;
		case COMPUTE_RATIO:
427
			perf_diff__compute_ratio(he, pair);
428
			break;
429
		case COMPUTE_WEIGHTED_DIFF:
430
			perf_diff__compute_wdiff(he, pair);
431
			break;
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
		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
hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
			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);
	}
467 468 469 470 471 472 473
	case COMPUTE_WEIGHTED_DIFF:
	{
		s64 l = left->diff.wdiff;
		s64 r = right->diff.wdiff;

		return r - l;
	}
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503
	default:
		BUG_ON(1);
	}

	return 0;
}

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)
{
504 505 506 507 508 509 510 511 512 513 514 515 516 517
	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);
518 519

	while (next != NULL) {
520
		struct hist_entry *he;
521

522 523
		he = rb_entry(next, struct hist_entry, rb_node_in);
		next = rb_next(&he->rb_node_in);
524

525 526
		insert_hist_entry_by_compute(&hists->entries, he, compute);
		hists__inc_nr_entries(hists, he);
527 528 529
	}
}

530
static void hists__process(struct hists *hists)
531 532
{
	if (show_baseline_only)
533
		hists__baseline_only(hists);
534

535
	if (sort_compute) {
536 537
		hists__precompute(hists);
		hists__compute_resort(hists);
538
	} else {
539
		hists__output_resort(hists);
540 541
	}

542
	hists__fprintf(hists, true, 0, 0, 0, stdout);
543 544
}

545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
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",
			d->idx, d->file,
			!d->idx ? "(Baseline)" : "");

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

560
static void data_process(void)
561
{
562 563
	struct perf_evlist *evlist_base = data__files[0].session->evlist;
	struct perf_evsel *evsel_base;
564
	bool first = true;
565

566 567 568
	list_for_each_entry(evsel_base, &evlist_base->entries, node) {
		struct data__file *d;
		int i;
569

570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
		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);
		}
586

587
		fprintf(stdout, "%s# Event '%s'\n#\n", first ? "" : "\n",
588
			perf_evsel__name(evsel_base));
589

590
		first = false;
591

592
		if (verbose || data__files_cnt > 2)
593 594
			data__fprintf();

595
		hists__process(&evsel_base->hists);
596 597
	}
}
598

599 600 601 602 603 604 605 606 607 608 609
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);
	}
}

610 611 612 613 614 615 616 617 618 619 620 621 622
static int __cmd_diff(void)
{
	struct data__file *d;
	int ret = -EINVAL, i;

	data__for_each_file(i, d) {
		d->session = perf_session__new(d->file, O_RDONLY, force,
					       false, &tool);
		if (!d->session) {
			pr_err("Failed to open %s\n", d->file);
			ret = -ENOMEM;
			goto out_delete;
		}
623

624 625 626 627 628
		ret = perf_session__process_events(d->session, &tool);
		if (ret) {
			pr_err("Failed to process %s\n", d->file);
			goto out_delete;
		}
629

630 631 632 633
		perf_evlist__collapse_resort(d->session->evlist);
	}

	data_process();
634

635 636 637 638
 out_delete:
	data__for_each_file(i, d) {
		if (d->session)
			perf_session__delete(d->session);
639 640

		data__free(d);
641
	}
642

643
	free(data__files);
644 645 646
	return ret;
}

647
static const char * const diff_usage[] = {
648
	"perf diff [<options>] [old_file] [new_file]",
649
	NULL,
650 651 652
};

static const struct option options[] = {
653
	OPT_INCR('v', "verbose", &verbose,
654
		    "be more verbose (show symbol address, etc)"),
655 656
	OPT_BOOLEAN('b', "baseline-only", &show_baseline_only,
		    "Show only items with match in baseline"),
657 658
	OPT_CALLBACK('c', "compute", &compute,
		     "delta,ratio,wdiff:w1,w2 (default delta)",
659 660
		     "Entries differential computation selection",
		     setup_compute),
661 662
	OPT_BOOLEAN('p', "period", &show_period,
		    "Show period values."),
663 664
	OPT_BOOLEAN('F', "formula", &show_formula,
		    "Show formula."),
665 666 667 668 669
	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"),
670 671 672 673 674 675
	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"),
676 677 678 679 680
	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."),
681 682
	OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
		    "Look for files with symbols relative to this directory"),
683 684 685
	OPT_END()
};

686
static double baseline_percent(struct hist_entry *he)
687
{
688 689 690
	struct hists *hists = he->hists;
	return 100.0 * he->stat.period / hists->stats.total_period;
}
691

692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
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);
727
		break;
728 729

	default:
730
		break;
731 732 733 734 735 736 737 738 739 740 741 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 778 779 780 781 782
	}
}

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
			diff = perf_diff__compute_delta(he, pair);

		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
			ratio = perf_diff__compute_ratio(he, pair);

		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
			wdiff = perf_diff__compute_wdiff(he, pair);

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

	case PERF_HPP_DIFF__FORMULA:
		perf_diff__formula(he, pair, buf, size);
783
		break;
784 785 786 787 788

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

789 790 791
	default:
		BUG_ON(1);
	};
792 793
}

794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
static struct hist_entry *get_pair(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);

	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;
}

811
static void
812 813
__hpp__entry_global(struct hist_entry *he, struct diff_hpp_fmt *dfmt,
		    char *buf, size_t size)
814
{
815 816
	struct hist_entry *pair = get_pair(he, dfmt);
	int idx = dfmt->idx;
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835

	/* 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] = " ";

836
	__hpp__entry_global(he, dfmt, buf, MAX_COL_WIDTH);
837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864

	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;
}

865
static void init_header(struct data__file *d, struct diff_hpp_fmt *dfmt)
866 867 868 869 870 871 872 873 874 875 876 877 878 879
{
#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);

880 881 882
	if (data__files_cnt > 2)
		scnprintf(buf, MAX_HEADER_NAME, "%s/%d", header, d->idx);

883 884 885 886 887 888 889 890 891 892 893 894 895 896
#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
}

897
static void data__hpp_register(struct data__file *d, int idx)
898
{
899 900 901 902 903 904 905 906 907 908 909 910
	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;
911

912
	init_header(d, dfmt);
913
	perf_hpp__column_register(fmt);
914 915 916 917
}

static void ui_init(void)
{
918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
	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);
933

934 935 936 937 938 939 940 941 942
		/*
		 * 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);
943

944 945 946
		if (show_period)
			data__hpp_register(d, i ? PERF_HPP_DIFF__PERIOD :
						  PERF_HPP_DIFF__PERIOD_BASELINE);
947
	}
948 949
}

950
static int data_init(int argc, const char **argv)
951
{
952 953 954 955 956
	struct data__file *d;
	static const char *defaults[] = {
		"perf.data.old",
		"perf.data",
	};
957
	bool use_default = true;
958 959 960 961
	int i;

	data__files_cnt = 2;

962
	if (argc) {
963
		if (argc == 1)
964
			defaults[1] = argv[0];
965 966 967 968
		else {
			data__files_cnt = argc;
			use_default = false;
		}
969 970
	} else if (symbol_conf.default_guest_vmlinux_name ||
		   symbol_conf.default_guest_kallsyms) {
971 972
		defaults[0] = "perf.data.host";
		defaults[1] = "perf.data.guest";
973 974
	}

975 976 977 978 979
	data__files = zalloc(sizeof(*data__files) * data__files_cnt);
	if (!data__files)
		return -ENOMEM;

	data__for_each_file(i, d) {
980
		d->file = use_default ? defaults[i] : argv[i];
981 982 983 984 985 986 987 988 989 990 991
		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);

992 993 994
	if (symbol__init() < 0)
		return -1;

995 996 997
	if (data_init(argc, argv) < 0)
		return -1;

998 999
	ui_init();

1000 1001 1002
	if (setup_sorting() < 0)
		usage_with_options(diff_usage, options);

1003
	setup_pager();
1004

1005
	sort__setup_elide(NULL);
1006

1007 1008
	return __cmd_diff();
}