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. */ 25enum { 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 37struct diff_hpp_fmt { 38 struct perf_hpp_fmt fmt; 39 int idx; 40 char *header; 41 int header_width; 42}; 43 44struct 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 52static struct data__file *data__files; 53static 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 63static bool force; 64static bool show_period; 65static bool show_formula; 66static bool show_baseline_only; 67static unsigned int sort_compute; 68 69static s64 compute_wdiff_w1; 70static s64 compute_wdiff_w2; 71 72enum { 73 COMPUTE_DELTA, 74 COMPUTE_RATIO, 75 COMPUTE_WEIGHTED_DIFF, 76 COMPUTE_MAX, 77}; 78 79const char *compute_names[COMPUTE_MAX] = { 80 [COMPUTE_DELTA] = "delta", 81 [COMPUTE_RATIO] = "ratio", 82 [COMPUTE_WEIGHTED_DIFF] = "wdiff", 83}; 84 85static int compute; 86 87static 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 95static 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 128static 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 164static 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 177static 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 220static 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 227static 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 237static 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 247static 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 259static 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 276static 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 285static 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 296static 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 313static 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 323static 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 357static 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 369static 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 382static 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 393static struct data__file *fmt_to_data_file(struct perf_hpp_fmt *fmt) 394{ 395 struct diff_hpp_fmt *dfmt = container_of(fmt, struct diff_hpp_fmt, fmt); 396 void *ptr = dfmt - dfmt->idx; 397 struct data__file *d = container_of(ptr, struct data__file, fmt); 398 399 return d; 400} 401 402static struct hist_entry* 403get_pair_data(struct hist_entry *he, struct data__file *d) 404{ 405 if (hist_entry__has_pairs(he)) { 406 struct hist_entry *pair; 407 408 list_for_each_entry(pair, &he->pairs.head, pairs.node) 409 if (pair->hists == d->hists) 410 return pair; 411 } 412 413 return NULL; 414} 415 416static struct hist_entry* 417get_pair_fmt(struct hist_entry *he, struct diff_hpp_fmt *dfmt) 418{ 419 struct data__file *d = fmt_to_data_file(&dfmt->fmt); 420 421 return get_pair_data(he, d); 422} 423 424static void hists__baseline_only(struct hists *hists) 425{ 426 struct rb_root *root; 427 struct rb_node *next; 428 429 if (sort__need_collapse) 430 root = &hists->entries_collapsed; 431 else 432 root = hists->entries_in; 433 434 next = rb_first(root); 435 while (next != NULL) { 436 struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in); 437 438 next = rb_next(&he->rb_node_in); 439 if (!hist_entry__next_pair(he)) { 440 rb_erase(&he->rb_node_in, root); 441 hist_entry__delete(he); 442 } 443 } 444} 445 446static void hists__precompute(struct hists *hists) 447{ 448 struct rb_root *root; 449 struct rb_node *next; 450 451 if (sort__need_collapse) 452 root = &hists->entries_collapsed; 453 else 454 root = hists->entries_in; 455 456 next = rb_first(root); 457 while (next != NULL) { 458 struct hist_entry *he, *pair; 459 struct data__file *d; 460 int i; 461 462 he = rb_entry(next, struct hist_entry, rb_node_in); 463 next = rb_next(&he->rb_node_in); 464 465 data__for_each_file_new(i, d) { 466 pair = get_pair_data(he, d); 467 if (!pair) 468 continue; 469 470 switch (compute) { 471 case COMPUTE_DELTA: 472 compute_delta(he, pair); 473 break; 474 case COMPUTE_RATIO: 475 compute_ratio(he, pair); 476 break; 477 case COMPUTE_WEIGHTED_DIFF: 478 compute_wdiff(he, pair); 479 break; 480 default: 481 BUG_ON(1); 482 } 483 } 484 } 485} 486 487static int64_t cmp_doubles(double l, double r) 488{ 489 if (l > r) 490 return -1; 491 else if (l < r) 492 return 1; 493 else 494 return 0; 495} 496 497static int64_t 498__hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right, 499 int c) 500{ 501 switch (c) { 502 case COMPUTE_DELTA: 503 { 504 double l = left->diff.period_ratio_delta; 505 double r = right->diff.period_ratio_delta; 506 507 return cmp_doubles(l, r); 508 } 509 case COMPUTE_RATIO: 510 { 511 double l = left->diff.period_ratio; 512 double r = right->diff.period_ratio; 513 514 return cmp_doubles(l, r); 515 } 516 case COMPUTE_WEIGHTED_DIFF: 517 { 518 s64 l = left->diff.wdiff; 519 s64 r = right->diff.wdiff; 520 521 return r - l; 522 } 523 default: 524 BUG_ON(1); 525 } 526 527 return 0; 528} 529 530static int64_t 531hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right, 532 int c, int sort_idx) 533{ 534 bool pairs_left = hist_entry__has_pairs(left); 535 bool pairs_right = hist_entry__has_pairs(right); 536 struct hist_entry *p_right, *p_left; 537 538 if (!pairs_left && !pairs_right) 539 return 0; 540 541 if (!pairs_left || !pairs_right) 542 return pairs_left ? -1 : 1; 543 544 p_left = get_pair_data(left, &data__files[sort_idx]); 545 p_right = get_pair_data(right, &data__files[sort_idx]); 546 547 if (!p_left && !p_right) 548 return 0; 549 550 if (!p_left || !p_right) 551 return p_left ? -1 : 1; 552 553 /* 554 * We have 2 entries of same kind, let's 555 * make the data comparison. 556 */ 557 return __hist_entry__cmp_compute(p_left, p_right, c); 558} 559 560static int64_t 561hist_entry__cmp_compute_idx(struct hist_entry *left, struct hist_entry *right, 562 int c, int sort_idx) 563{ 564 struct hist_entry *p_right, *p_left; 565 566 p_left = get_pair_data(left, &data__files[sort_idx]); 567 p_right = get_pair_data(right, &data__files[sort_idx]); 568 569 if (!p_left && !p_right) 570 return 0; 571 572 if (!p_left || !p_right) 573 return p_left ? -1 : 1; 574 575 if (c != COMPUTE_DELTA) { 576 /* 577 * The delta can be computed without the baseline, but 578 * others are not. Put those entries which have no 579 * values below. 580 */ 581 if (left->dummy && right->dummy) 582 return 0; 583 584 if (left->dummy || right->dummy) 585 return left->dummy ? 1 : -1; 586 } 587 588 return __hist_entry__cmp_compute(p_left, p_right, c); 589} 590 591static int64_t 592hist_entry__cmp_nop(struct perf_hpp_fmt *fmt __maybe_unused, 593 struct hist_entry *left __maybe_unused, 594 struct hist_entry *right __maybe_unused) 595{ 596 return 0; 597} 598 599static int64_t 600hist_entry__cmp_baseline(struct perf_hpp_fmt *fmt __maybe_unused, 601 struct hist_entry *left, struct hist_entry *right) 602{ 603 if (left->stat.period == right->stat.period) 604 return 0; 605 return left->stat.period > right->stat.period ? 1 : -1; 606} 607 608static int64_t 609hist_entry__cmp_delta(struct perf_hpp_fmt *fmt, 610 struct hist_entry *left, struct hist_entry *right) 611{ 612 struct data__file *d = fmt_to_data_file(fmt); 613 614 return hist_entry__cmp_compute(right, left, COMPUTE_DELTA, d->idx); 615} 616 617static int64_t 618hist_entry__cmp_ratio(struct perf_hpp_fmt *fmt, 619 struct hist_entry *left, struct hist_entry *right) 620{ 621 struct data__file *d = fmt_to_data_file(fmt); 622 623 return hist_entry__cmp_compute(right, left, COMPUTE_RATIO, d->idx); 624} 625 626static int64_t 627hist_entry__cmp_wdiff(struct perf_hpp_fmt *fmt, 628 struct hist_entry *left, struct hist_entry *right) 629{ 630 struct data__file *d = fmt_to_data_file(fmt); 631 632 return hist_entry__cmp_compute(right, left, COMPUTE_WEIGHTED_DIFF, d->idx); 633} 634 635static int64_t 636hist_entry__cmp_delta_idx(struct perf_hpp_fmt *fmt __maybe_unused, 637 struct hist_entry *left, struct hist_entry *right) 638{ 639 return hist_entry__cmp_compute_idx(right, left, COMPUTE_DELTA, 640 sort_compute); 641} 642 643static int64_t 644hist_entry__cmp_ratio_idx(struct perf_hpp_fmt *fmt __maybe_unused, 645 struct hist_entry *left, struct hist_entry *right) 646{ 647 return hist_entry__cmp_compute_idx(right, left, COMPUTE_RATIO, 648 sort_compute); 649} 650 651static int64_t 652hist_entry__cmp_wdiff_idx(struct perf_hpp_fmt *fmt __maybe_unused, 653 struct hist_entry *left, struct hist_entry *right) 654{ 655 return hist_entry__cmp_compute_idx(right, left, COMPUTE_WEIGHTED_DIFF, 656 sort_compute); 657} 658 659static void hists__process(struct hists *hists) 660{ 661 if (show_baseline_only) 662 hists__baseline_only(hists); 663 664 hists__precompute(hists); 665 hists__output_resort(hists, NULL); 666 667 hists__fprintf(hists, true, 0, 0, 0, stdout); 668} 669 670static void data__fprintf(void) 671{ 672 struct data__file *d; 673 int i; 674 675 fprintf(stdout, "# Data files:\n"); 676 677 data__for_each_file(i, d) 678 fprintf(stdout, "# [%d] %s %s\n", 679 d->idx, d->file.path, 680 !d->idx ? "(Baseline)" : ""); 681 682 fprintf(stdout, "#\n"); 683} 684 685static void data_process(void) 686{ 687 struct perf_evlist *evlist_base = data__files[0].session->evlist; 688 struct perf_evsel *evsel_base; 689 bool first = true; 690 691 evlist__for_each(evlist_base, evsel_base) { 692 struct hists *hists_base = evsel__hists(evsel_base); 693 struct data__file *d; 694 int i; 695 696 data__for_each_file_new(i, d) { 697 struct perf_evlist *evlist = d->session->evlist; 698 struct perf_evsel *evsel; 699 struct hists *hists; 700 701 evsel = evsel_match(evsel_base, evlist); 702 if (!evsel) 703 continue; 704 705 hists = evsel__hists(evsel); 706 d->hists = hists; 707 708 hists__match(hists_base, hists); 709 710 if (!show_baseline_only) 711 hists__link(hists_base, hists); 712 } 713 714 fprintf(stdout, "%s# Event '%s'\n#\n", first ? "" : "\n", 715 perf_evsel__name(evsel_base)); 716 717 first = false; 718 719 if (verbose || data__files_cnt > 2) 720 data__fprintf(); 721 722 hists__process(hists_base); 723 } 724} 725 726static void data__free(struct data__file *d) 727{ 728 int col; 729 730 for (col = 0; col < PERF_HPP_DIFF__MAX_INDEX; col++) { 731 struct diff_hpp_fmt *fmt = &d->fmt[col]; 732 733 zfree(&fmt->header); 734 } 735} 736 737static int __cmd_diff(void) 738{ 739 struct data__file *d; 740 int ret = -EINVAL, i; 741 742 data__for_each_file(i, d) { 743 d->session = perf_session__new(&d->file, false, &tool); 744 if (!d->session) { 745 pr_err("Failed to open %s\n", d->file.path); 746 ret = -1; 747 goto out_delete; 748 } 749 750 ret = perf_session__process_events(d->session); 751 if (ret) { 752 pr_err("Failed to process %s\n", d->file.path); 753 goto out_delete; 754 } 755 756 perf_evlist__collapse_resort(d->session->evlist); 757 } 758 759 data_process(); 760 761 out_delete: 762 data__for_each_file(i, d) { 763 if (d->session) 764 perf_session__delete(d->session); 765 766 data__free(d); 767 } 768 769 free(data__files); 770 return ret; 771} 772 773static const char * const diff_usage[] = { 774 "perf diff [<options>] [old_file] [new_file]", 775 NULL, 776}; 777 778static const struct option options[] = { 779 OPT_INCR('v', "verbose", &verbose, 780 "be more verbose (show symbol address, etc)"), 781 OPT_BOOLEAN('b', "baseline-only", &show_baseline_only, 782 "Show only items with match in baseline"), 783 OPT_CALLBACK('c', "compute", &compute, 784 "delta,ratio,wdiff:w1,w2 (default delta)", 785 "Entries differential computation selection", 786 setup_compute), 787 OPT_BOOLEAN('p', "period", &show_period, 788 "Show period values."), 789 OPT_BOOLEAN('F', "formula", &show_formula, 790 "Show formula."), 791 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, 792 "dump raw trace in ASCII"), 793 OPT_BOOLEAN('f', "force", &force, "don't complain, do it"), 794 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, 795 "file", "kallsyms pathname"), 796 OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules, 797 "load module symbols - WARNING: use only with -k and LIVE kernel"), 798 OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]", 799 "only consider symbols in these dsos"), 800 OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]", 801 "only consider symbols in these comms"), 802 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]", 803 "only consider these symbols"), 804 OPT_STRING('s', "sort", &sort_order, "key[,key2...]", 805 "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..." 806 " Please refer the man page for the complete list."), 807 OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator", 808 "separator for columns, no spaces will be added between " 809 "columns '.' is reserved."), 810 OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory", 811 "Look for files with symbols relative to this directory"), 812 OPT_UINTEGER('o', "order", &sort_compute, "Specify compute sorting."), 813 OPT_CALLBACK(0, "percentage", NULL, "relative|absolute", 814 "How to display percentage of filtered entries", parse_filter_percentage), 815 OPT_END() 816}; 817 818static double baseline_percent(struct hist_entry *he) 819{ 820 u64 total = hists__total_period(he->hists); 821 822 return 100.0 * he->stat.period / total; 823} 824 825static int hpp__color_baseline(struct perf_hpp_fmt *fmt, 826 struct perf_hpp *hpp, struct hist_entry *he) 827{ 828 struct diff_hpp_fmt *dfmt = 829 container_of(fmt, struct diff_hpp_fmt, fmt); 830 double percent = baseline_percent(he); 831 char pfmt[20] = " "; 832 833 if (!he->dummy) { 834 scnprintf(pfmt, 20, "%%%d.2f%%%%", dfmt->header_width - 1); 835 return percent_color_snprintf(hpp->buf, hpp->size, 836 pfmt, percent); 837 } else 838 return scnprintf(hpp->buf, hpp->size, "%*s", 839 dfmt->header_width, pfmt); 840} 841 842static int hpp__entry_baseline(struct hist_entry *he, char *buf, size_t size) 843{ 844 double percent = baseline_percent(he); 845 const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%"; 846 int ret = 0; 847 848 if (!he->dummy) 849 ret = scnprintf(buf, size, fmt, percent); 850 851 return ret; 852} 853 854static int __hpp__color_compare(struct perf_hpp_fmt *fmt, 855 struct perf_hpp *hpp, struct hist_entry *he, 856 int comparison_method) 857{ 858 struct diff_hpp_fmt *dfmt = 859 container_of(fmt, struct diff_hpp_fmt, fmt); 860 struct hist_entry *pair = get_pair_fmt(he, dfmt); 861 double diff; 862 s64 wdiff; 863 char pfmt[20] = " "; 864 865 if (!pair) 866 goto no_print; 867 868 switch (comparison_method) { 869 case COMPUTE_DELTA: 870 if (pair->diff.computed) 871 diff = pair->diff.period_ratio_delta; 872 else 873 diff = compute_delta(he, pair); 874 875 scnprintf(pfmt, 20, "%%%+d.2f%%%%", dfmt->header_width - 1); 876 return percent_color_snprintf(hpp->buf, hpp->size, 877 pfmt, diff); 878 case COMPUTE_RATIO: 879 if (he->dummy) 880 goto dummy_print; 881 if (pair->diff.computed) 882 diff = pair->diff.period_ratio; 883 else 884 diff = compute_ratio(he, pair); 885 886 scnprintf(pfmt, 20, "%%%d.6f", dfmt->header_width); 887 return value_color_snprintf(hpp->buf, hpp->size, 888 pfmt, diff); 889 case COMPUTE_WEIGHTED_DIFF: 890 if (he->dummy) 891 goto dummy_print; 892 if (pair->diff.computed) 893 wdiff = pair->diff.wdiff; 894 else 895 wdiff = compute_wdiff(he, pair); 896 897 scnprintf(pfmt, 20, "%%14ld", dfmt->header_width); 898 return color_snprintf(hpp->buf, hpp->size, 899 get_percent_color(wdiff), 900 pfmt, wdiff); 901 default: 902 BUG_ON(1); 903 } 904dummy_print: 905 return scnprintf(hpp->buf, hpp->size, "%*s", 906 dfmt->header_width, "N/A"); 907no_print: 908 return scnprintf(hpp->buf, hpp->size, "%*s", 909 dfmt->header_width, pfmt); 910} 911 912static int hpp__color_delta(struct perf_hpp_fmt *fmt, 913 struct perf_hpp *hpp, struct hist_entry *he) 914{ 915 return __hpp__color_compare(fmt, hpp, he, COMPUTE_DELTA); 916} 917 918static int hpp__color_ratio(struct perf_hpp_fmt *fmt, 919 struct perf_hpp *hpp, struct hist_entry *he) 920{ 921 return __hpp__color_compare(fmt, hpp, he, COMPUTE_RATIO); 922} 923 924static int hpp__color_wdiff(struct perf_hpp_fmt *fmt, 925 struct perf_hpp *hpp, struct hist_entry *he) 926{ 927 return __hpp__color_compare(fmt, hpp, he, COMPUTE_WEIGHTED_DIFF); 928} 929 930static void 931hpp__entry_unpair(struct hist_entry *he, int idx, char *buf, size_t size) 932{ 933 switch (idx) { 934 case PERF_HPP_DIFF__PERIOD_BASELINE: 935 scnprintf(buf, size, "%" PRIu64, he->stat.period); 936 break; 937 938 default: 939 break; 940 } 941} 942 943static void 944hpp__entry_pair(struct hist_entry *he, struct hist_entry *pair, 945 int idx, char *buf, size_t size) 946{ 947 double diff; 948 double ratio; 949 s64 wdiff; 950 951 switch (idx) { 952 case PERF_HPP_DIFF__DELTA: 953 if (pair->diff.computed) 954 diff = pair->diff.period_ratio_delta; 955 else 956 diff = compute_delta(he, pair); 957 958 scnprintf(buf, size, "%+4.2F%%", diff); 959 break; 960 961 case PERF_HPP_DIFF__RATIO: 962 /* No point for ratio number if we are dummy.. */ 963 if (he->dummy) { 964 scnprintf(buf, size, "N/A"); 965 break; 966 } 967 968 if (pair->diff.computed) 969 ratio = pair->diff.period_ratio; 970 else 971 ratio = compute_ratio(he, pair); 972 973 if (ratio > 0.0) 974 scnprintf(buf, size, "%14.6F", ratio); 975 break; 976 977 case PERF_HPP_DIFF__WEIGHTED_DIFF: 978 /* No point for wdiff number if we are dummy.. */ 979 if (he->dummy) { 980 scnprintf(buf, size, "N/A"); 981 break; 982 } 983 984 if (pair->diff.computed) 985 wdiff = pair->diff.wdiff; 986 else 987 wdiff = compute_wdiff(he, pair); 988 989 if (wdiff != 0) 990 scnprintf(buf, size, "%14ld", wdiff); 991 break; 992 993 case PERF_HPP_DIFF__FORMULA: 994 formula_fprintf(he, pair, buf, size); 995 break; 996 997 case PERF_HPP_DIFF__PERIOD: 998 scnprintf(buf, size, "%" PRIu64, pair->stat.period); 999 break; 1000 1001 default: 1002 BUG_ON(1); 1003 }; 1004} 1005 1006static void 1007__hpp__entry_global(struct hist_entry *he, struct diff_hpp_fmt *dfmt, 1008 char *buf, size_t size) 1009{ 1010 struct hist_entry *pair = get_pair_fmt(he, dfmt); 1011 int idx = dfmt->idx; 1012 1013 /* baseline is special */ 1014 if (idx == PERF_HPP_DIFF__BASELINE) 1015 hpp__entry_baseline(he, buf, size); 1016 else { 1017 if (pair) 1018 hpp__entry_pair(he, pair, idx, buf, size); 1019 else 1020 hpp__entry_unpair(he, idx, buf, size); 1021 } 1022} 1023 1024static int hpp__entry_global(struct perf_hpp_fmt *_fmt, struct perf_hpp *hpp, 1025 struct hist_entry *he) 1026{ 1027 struct diff_hpp_fmt *dfmt = 1028 container_of(_fmt, struct diff_hpp_fmt, fmt); 1029 char buf[MAX_COL_WIDTH] = " "; 1030 1031 __hpp__entry_global(he, dfmt, buf, MAX_COL_WIDTH); 1032 1033 if (symbol_conf.field_sep) 1034 return scnprintf(hpp->buf, hpp->size, "%s", buf); 1035 else 1036 return scnprintf(hpp->buf, hpp->size, "%*s", 1037 dfmt->header_width, buf); 1038} 1039 1040static int hpp__header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 1041 struct perf_evsel *evsel __maybe_unused) 1042{ 1043 struct diff_hpp_fmt *dfmt = 1044 container_of(fmt, struct diff_hpp_fmt, fmt); 1045 1046 BUG_ON(!dfmt->header); 1047 return scnprintf(hpp->buf, hpp->size, dfmt->header); 1048} 1049 1050static int hpp__width(struct perf_hpp_fmt *fmt, 1051 struct perf_hpp *hpp __maybe_unused, 1052 struct perf_evsel *evsel __maybe_unused) 1053{ 1054 struct diff_hpp_fmt *dfmt = 1055 container_of(fmt, struct diff_hpp_fmt, fmt); 1056 1057 BUG_ON(dfmt->header_width <= 0); 1058 return dfmt->header_width; 1059} 1060 1061static void init_header(struct data__file *d, struct diff_hpp_fmt *dfmt) 1062{ 1063#define MAX_HEADER_NAME 100 1064 char buf_indent[MAX_HEADER_NAME]; 1065 char buf[MAX_HEADER_NAME]; 1066 const char *header = NULL; 1067 int width = 0; 1068 1069 BUG_ON(dfmt->idx >= PERF_HPP_DIFF__MAX_INDEX); 1070 header = columns[dfmt->idx].name; 1071 width = columns[dfmt->idx].width; 1072 1073 /* Only our defined HPP fmts should appear here. */ 1074 BUG_ON(!header); 1075 1076 if (data__files_cnt > 2) 1077 scnprintf(buf, MAX_HEADER_NAME, "%s/%d", header, d->idx); 1078 1079#define NAME (data__files_cnt > 2 ? buf : header) 1080 dfmt->header_width = width; 1081 width = (int) strlen(NAME); 1082 if (dfmt->header_width < width) 1083 dfmt->header_width = width; 1084 1085 scnprintf(buf_indent, MAX_HEADER_NAME, "%*s", 1086 dfmt->header_width, NAME); 1087 1088 dfmt->header = strdup(buf_indent); 1089#undef MAX_HEADER_NAME 1090#undef NAME 1091} 1092 1093static void data__hpp_register(struct data__file *d, int idx) 1094{ 1095 struct diff_hpp_fmt *dfmt = &d->fmt[idx]; 1096 struct perf_hpp_fmt *fmt = &dfmt->fmt; 1097 1098 dfmt->idx = idx; 1099 1100 fmt->header = hpp__header; 1101 fmt->width = hpp__width; 1102 fmt->entry = hpp__entry_global; 1103 fmt->cmp = hist_entry__cmp_nop; 1104 fmt->collapse = hist_entry__cmp_nop; 1105 1106 /* TODO more colors */ 1107 switch (idx) { 1108 case PERF_HPP_DIFF__BASELINE: 1109 fmt->color = hpp__color_baseline; 1110 fmt->sort = hist_entry__cmp_baseline; 1111 break; 1112 case PERF_HPP_DIFF__DELTA: 1113 fmt->color = hpp__color_delta; 1114 fmt->sort = hist_entry__cmp_delta; 1115 break; 1116 case PERF_HPP_DIFF__RATIO: 1117 fmt->color = hpp__color_ratio; 1118 fmt->sort = hist_entry__cmp_ratio; 1119 break; 1120 case PERF_HPP_DIFF__WEIGHTED_DIFF: 1121 fmt->color = hpp__color_wdiff; 1122 fmt->sort = hist_entry__cmp_wdiff; 1123 break; 1124 default: 1125 fmt->sort = hist_entry__cmp_nop; 1126 break; 1127 } 1128 1129 init_header(d, dfmt); 1130 perf_hpp__column_register(fmt); 1131 perf_hpp__register_sort_field(fmt); 1132} 1133 1134static int ui_init(void) 1135{ 1136 struct data__file *d; 1137 struct perf_hpp_fmt *fmt; 1138 int i; 1139 1140 data__for_each_file(i, d) { 1141 1142 /* 1143 * Baseline or compute realted columns: 1144 * 1145 * PERF_HPP_DIFF__BASELINE 1146 * PERF_HPP_DIFF__DELTA 1147 * PERF_HPP_DIFF__RATIO 1148 * PERF_HPP_DIFF__WEIGHTED_DIFF 1149 */ 1150 data__hpp_register(d, i ? compute_2_hpp[compute] : 1151 PERF_HPP_DIFF__BASELINE); 1152 1153 /* 1154 * And the rest: 1155 * 1156 * PERF_HPP_DIFF__FORMULA 1157 * PERF_HPP_DIFF__PERIOD 1158 * PERF_HPP_DIFF__PERIOD_BASELINE 1159 */ 1160 if (show_formula && i) 1161 data__hpp_register(d, PERF_HPP_DIFF__FORMULA); 1162 1163 if (show_period) 1164 data__hpp_register(d, i ? PERF_HPP_DIFF__PERIOD : 1165 PERF_HPP_DIFF__PERIOD_BASELINE); 1166 } 1167 1168 if (!sort_compute) 1169 return 0; 1170 1171 /* 1172 * Prepend an fmt to sort on columns at 'sort_compute' first. 1173 * This fmt is added only to the sort list but not to the 1174 * output fields list. 1175 * 1176 * Note that this column (data) can be compared twice - one 1177 * for this 'sort_compute' fmt and another for the normal 1178 * diff_hpp_fmt. But it shouldn't a problem as most entries 1179 * will be sorted out by first try or baseline and comparing 1180 * is not a costly operation. 1181 */ 1182 fmt = zalloc(sizeof(*fmt)); 1183 if (fmt == NULL) { 1184 pr_err("Memory allocation failed\n"); 1185 return -1; 1186 } 1187 1188 fmt->cmp = hist_entry__cmp_nop; 1189 fmt->collapse = hist_entry__cmp_nop; 1190 1191 switch (compute) { 1192 case COMPUTE_DELTA: 1193 fmt->sort = hist_entry__cmp_delta_idx; 1194 break; 1195 case COMPUTE_RATIO: 1196 fmt->sort = hist_entry__cmp_ratio_idx; 1197 break; 1198 case COMPUTE_WEIGHTED_DIFF: 1199 fmt->sort = hist_entry__cmp_wdiff_idx; 1200 break; 1201 default: 1202 BUG_ON(1); 1203 } 1204 1205 list_add(&fmt->sort_list, &perf_hpp__sort_list); 1206 return 0; 1207} 1208 1209static int data_init(int argc, const char **argv) 1210{ 1211 struct data__file *d; 1212 static const char *defaults[] = { 1213 "perf.data.old", 1214 "perf.data", 1215 }; 1216 bool use_default = true; 1217 int i; 1218 1219 data__files_cnt = 2; 1220 1221 if (argc) { 1222 if (argc == 1) 1223 defaults[1] = argv[0]; 1224 else { 1225 data__files_cnt = argc; 1226 use_default = false; 1227 } 1228 } else if (perf_guest) { 1229 defaults[0] = "perf.data.host"; 1230 defaults[1] = "perf.data.guest"; 1231 } 1232 1233 if (sort_compute >= (unsigned int) data__files_cnt) { 1234 pr_err("Order option out of limit.\n"); 1235 return -EINVAL; 1236 } 1237 1238 data__files = zalloc(sizeof(*data__files) * data__files_cnt); 1239 if (!data__files) 1240 return -ENOMEM; 1241 1242 data__for_each_file(i, d) { 1243 struct perf_data_file *file = &d->file; 1244 1245 file->path = use_default ? defaults[i] : argv[i]; 1246 file->mode = PERF_DATA_MODE_READ, 1247 file->force = force, 1248 1249 d->idx = i; 1250 } 1251 1252 return 0; 1253} 1254 1255int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused) 1256{ 1257 int ret = hists__init(); 1258 1259 if (ret < 0) 1260 return ret; 1261 1262 perf_config(perf_default_config, NULL); 1263 1264 argc = parse_options(argc, argv, options, diff_usage, 0); 1265 1266 if (symbol__init(NULL) < 0) 1267 return -1; 1268 1269 if (data_init(argc, argv) < 0) 1270 return -1; 1271 1272 if (ui_init() < 0) 1273 return -1; 1274 1275 sort__mode = SORT_MODE__DIFF; 1276 1277 if (setup_sorting() < 0) 1278 usage_with_options(diff_usage, options); 1279 1280 setup_pager(); 1281 1282 sort__setup_elide(NULL); 1283 1284 return __cmd_diff(); 1285} 1286