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 20 #include <stdlib.h> 21 #include <math.h> 22 23 /* Diff command specific HPP columns. */ 24 enum { 25 PERF_HPP_DIFF__BASELINE, 26 PERF_HPP_DIFF__PERIOD, 27 PERF_HPP_DIFF__PERIOD_BASELINE, 28 PERF_HPP_DIFF__DELTA, 29 PERF_HPP_DIFF__RATIO, 30 PERF_HPP_DIFF__WEIGHTED_DIFF, 31 PERF_HPP_DIFF__FORMULA, 32 33 PERF_HPP_DIFF__MAX_INDEX 34 }; 35 36 struct diff_hpp_fmt { 37 struct perf_hpp_fmt fmt; 38 int idx; 39 char *header; 40 int header_width; 41 }; 42 43 struct data__file { 44 struct perf_session *session; 45 const char *file; 46 int idx; 47 struct hists *hists; 48 struct diff_hpp_fmt fmt[PERF_HPP_DIFF__MAX_INDEX]; 49 }; 50 51 static struct data__file *data__files; 52 static int data__files_cnt; 53 54 #define data__for_each_file_start(i, d, s) \ 55 for (i = s, d = &data__files[s]; \ 56 i < data__files_cnt; \ 57 i++, d = &data__files[i]) 58 59 #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 static char diff__default_sort_order[] = "dso,symbol"; 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 = he->hists->stats.total_period; 223 return (period * 100.0) / total; 224 } 225 226 static double compute_delta(struct hist_entry *he, struct hist_entry *pair) 227 { 228 double old_percent = period_percent(he, he->stat.period); 229 double new_percent = period_percent(pair, pair->stat.period); 230 231 pair->diff.period_ratio_delta = new_percent - old_percent; 232 pair->diff.computed = true; 233 return pair->diff.period_ratio_delta; 234 } 235 236 static double compute_ratio(struct hist_entry *he, struct hist_entry *pair) 237 { 238 double old_period = he->stat.period ?: 1; 239 double new_period = pair->stat.period; 240 241 pair->diff.computed = true; 242 pair->diff.period_ratio = new_period / old_period; 243 return pair->diff.period_ratio; 244 } 245 246 static s64 compute_wdiff(struct hist_entry *he, struct hist_entry *pair) 247 { 248 u64 old_period = he->stat.period; 249 u64 new_period = pair->stat.period; 250 251 pair->diff.computed = true; 252 pair->diff.wdiff = new_period * compute_wdiff_w2 - 253 old_period * compute_wdiff_w1; 254 255 return pair->diff.wdiff; 256 } 257 258 static int formula_delta(struct hist_entry *he, struct hist_entry *pair, 259 char *buf, size_t size) 260 { 261 return scnprintf(buf, size, 262 "(%" PRIu64 " * 100 / %" PRIu64 ") - " 263 "(%" PRIu64 " * 100 / %" PRIu64 ")", 264 pair->stat.period, pair->hists->stats.total_period, 265 he->stat.period, he->hists->stats.total_period); 266 } 267 268 static int formula_ratio(struct hist_entry *he, struct hist_entry *pair, 269 char *buf, size_t size) 270 { 271 double old_period = he->stat.period; 272 double new_period = pair->stat.period; 273 274 return scnprintf(buf, size, "%.0F / %.0F", new_period, old_period); 275 } 276 277 static int formula_wdiff(struct hist_entry *he, struct hist_entry *pair, 278 char *buf, size_t size) 279 { 280 u64 old_period = he->stat.period; 281 u64 new_period = pair->stat.period; 282 283 return scnprintf(buf, size, 284 "(%" PRIu64 " * " "%" PRId64 ") - (%" PRIu64 " * " "%" PRId64 ")", 285 new_period, compute_wdiff_w2, old_period, compute_wdiff_w1); 286 } 287 288 static int formula_fprintf(struct hist_entry *he, struct hist_entry *pair, 289 char *buf, size_t size) 290 { 291 switch (compute) { 292 case COMPUTE_DELTA: 293 return formula_delta(he, pair, buf, size); 294 case COMPUTE_RATIO: 295 return formula_ratio(he, pair, buf, size); 296 case COMPUTE_WEIGHTED_DIFF: 297 return formula_wdiff(he, pair, buf, size); 298 default: 299 BUG_ON(1); 300 } 301 302 return -1; 303 } 304 305 static int hists__add_entry(struct hists *self, 306 struct addr_location *al, u64 period, 307 u64 weight) 308 { 309 if (__hists__add_entry(self, al, NULL, period, weight) != NULL) 310 return 0; 311 return -ENOMEM; 312 } 313 314 static int diff__process_sample_event(struct perf_tool *tool __maybe_unused, 315 union perf_event *event, 316 struct perf_sample *sample, 317 struct perf_evsel *evsel, 318 struct machine *machine) 319 { 320 struct addr_location al; 321 322 if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) { 323 pr_warning("problem processing %d event, skipping it.\n", 324 event->header.type); 325 return -1; 326 } 327 328 if (al.filtered) 329 return 0; 330 331 if (hists__add_entry(&evsel->hists, &al, sample->period, sample->weight)) { 332 pr_warning("problem incrementing symbol period, skipping event\n"); 333 return -1; 334 } 335 336 evsel->hists.stats.total_period += sample->period; 337 return 0; 338 } 339 340 static struct perf_tool tool = { 341 .sample = diff__process_sample_event, 342 .mmap = perf_event__process_mmap, 343 .comm = perf_event__process_comm, 344 .exit = perf_event__process_exit, 345 .fork = perf_event__process_fork, 346 .lost = perf_event__process_lost, 347 .ordered_samples = true, 348 .ordering_requires_timestamps = true, 349 }; 350 351 static struct perf_evsel *evsel_match(struct perf_evsel *evsel, 352 struct perf_evlist *evlist) 353 { 354 struct perf_evsel *e; 355 356 list_for_each_entry(e, &evlist->entries, node) 357 if (perf_evsel__match2(evsel, e)) 358 return e; 359 360 return NULL; 361 } 362 363 static void perf_evlist__collapse_resort(struct perf_evlist *evlist) 364 { 365 struct perf_evsel *evsel; 366 367 list_for_each_entry(evsel, &evlist->entries, node) { 368 struct hists *hists = &evsel->hists; 369 370 hists__collapse_resort(hists); 371 } 372 } 373 374 static struct hist_entry* 375 get_pair_data(struct hist_entry *he, struct data__file *d) 376 { 377 if (hist_entry__has_pairs(he)) { 378 struct hist_entry *pair; 379 380 list_for_each_entry(pair, &he->pairs.head, pairs.node) 381 if (pair->hists == d->hists) 382 return pair; 383 } 384 385 return NULL; 386 } 387 388 static struct hist_entry* 389 get_pair_fmt(struct hist_entry *he, struct diff_hpp_fmt *dfmt) 390 { 391 void *ptr = dfmt - dfmt->idx; 392 struct data__file *d = container_of(ptr, struct data__file, fmt); 393 394 return get_pair_data(he, d); 395 } 396 397 static void hists__baseline_only(struct hists *hists) 398 { 399 struct rb_root *root; 400 struct rb_node *next; 401 402 if (sort__need_collapse) 403 root = &hists->entries_collapsed; 404 else 405 root = hists->entries_in; 406 407 next = rb_first(root); 408 while (next != NULL) { 409 struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in); 410 411 next = rb_next(&he->rb_node_in); 412 if (!hist_entry__next_pair(he)) { 413 rb_erase(&he->rb_node_in, root); 414 hist_entry__free(he); 415 } 416 } 417 } 418 419 static void hists__precompute(struct hists *hists) 420 { 421 struct rb_root *root; 422 struct rb_node *next; 423 424 if (sort__need_collapse) 425 root = &hists->entries_collapsed; 426 else 427 root = hists->entries_in; 428 429 next = rb_first(root); 430 while (next != NULL) { 431 struct hist_entry *he, *pair; 432 433 he = rb_entry(next, struct hist_entry, rb_node_in); 434 next = rb_next(&he->rb_node_in); 435 436 pair = get_pair_data(he, &data__files[sort_compute]); 437 if (!pair) 438 continue; 439 440 switch (compute) { 441 case COMPUTE_DELTA: 442 compute_delta(he, pair); 443 break; 444 case COMPUTE_RATIO: 445 compute_ratio(he, pair); 446 break; 447 case COMPUTE_WEIGHTED_DIFF: 448 compute_wdiff(he, pair); 449 break; 450 default: 451 BUG_ON(1); 452 } 453 } 454 } 455 456 static int64_t cmp_doubles(double l, double r) 457 { 458 if (l > r) 459 return -1; 460 else if (l < r) 461 return 1; 462 else 463 return 0; 464 } 465 466 static int64_t 467 __hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right, 468 int c) 469 { 470 switch (c) { 471 case COMPUTE_DELTA: 472 { 473 double l = left->diff.period_ratio_delta; 474 double r = right->diff.period_ratio_delta; 475 476 return cmp_doubles(l, r); 477 } 478 case COMPUTE_RATIO: 479 { 480 double l = left->diff.period_ratio; 481 double r = right->diff.period_ratio; 482 483 return cmp_doubles(l, r); 484 } 485 case COMPUTE_WEIGHTED_DIFF: 486 { 487 s64 l = left->diff.wdiff; 488 s64 r = right->diff.wdiff; 489 490 return r - l; 491 } 492 default: 493 BUG_ON(1); 494 } 495 496 return 0; 497 } 498 499 static int64_t 500 hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right, 501 int c) 502 { 503 bool pairs_left = hist_entry__has_pairs(left); 504 bool pairs_right = hist_entry__has_pairs(right); 505 struct hist_entry *p_right, *p_left; 506 507 if (!pairs_left && !pairs_right) 508 return 0; 509 510 if (!pairs_left || !pairs_right) 511 return pairs_left ? -1 : 1; 512 513 p_left = get_pair_data(left, &data__files[sort_compute]); 514 p_right = get_pair_data(right, &data__files[sort_compute]); 515 516 if (!p_left && !p_right) 517 return 0; 518 519 if (!p_left || !p_right) 520 return p_left ? -1 : 1; 521 522 /* 523 * We have 2 entries of same kind, let's 524 * make the data comparison. 525 */ 526 return __hist_entry__cmp_compute(p_left, p_right, c); 527 } 528 529 static void insert_hist_entry_by_compute(struct rb_root *root, 530 struct hist_entry *he, 531 int c) 532 { 533 struct rb_node **p = &root->rb_node; 534 struct rb_node *parent = NULL; 535 struct hist_entry *iter; 536 537 while (*p != NULL) { 538 parent = *p; 539 iter = rb_entry(parent, struct hist_entry, rb_node); 540 if (hist_entry__cmp_compute(he, iter, c) < 0) 541 p = &(*p)->rb_left; 542 else 543 p = &(*p)->rb_right; 544 } 545 546 rb_link_node(&he->rb_node, parent, p); 547 rb_insert_color(&he->rb_node, root); 548 } 549 550 static void hists__compute_resort(struct hists *hists) 551 { 552 struct rb_root *root; 553 struct rb_node *next; 554 555 if (sort__need_collapse) 556 root = &hists->entries_collapsed; 557 else 558 root = hists->entries_in; 559 560 hists->entries = RB_ROOT; 561 next = rb_first(root); 562 563 hists->nr_entries = 0; 564 hists->stats.total_period = 0; 565 hists__reset_col_len(hists); 566 567 while (next != NULL) { 568 struct hist_entry *he; 569 570 he = rb_entry(next, struct hist_entry, rb_node_in); 571 next = rb_next(&he->rb_node_in); 572 573 insert_hist_entry_by_compute(&hists->entries, he, compute); 574 hists__inc_nr_entries(hists, he); 575 } 576 } 577 578 static void hists__process(struct hists *hists) 579 { 580 if (show_baseline_only) 581 hists__baseline_only(hists); 582 583 if (sort_compute) { 584 hists__precompute(hists); 585 hists__compute_resort(hists); 586 } else { 587 hists__output_resort(hists); 588 } 589 590 hists__fprintf(hists, true, 0, 0, 0, stdout); 591 } 592 593 static void data__fprintf(void) 594 { 595 struct data__file *d; 596 int i; 597 598 fprintf(stdout, "# Data files:\n"); 599 600 data__for_each_file(i, d) 601 fprintf(stdout, "# [%d] %s %s\n", 602 d->idx, d->file, 603 !d->idx ? "(Baseline)" : ""); 604 605 fprintf(stdout, "#\n"); 606 } 607 608 static void data_process(void) 609 { 610 struct perf_evlist *evlist_base = data__files[0].session->evlist; 611 struct perf_evsel *evsel_base; 612 bool first = true; 613 614 list_for_each_entry(evsel_base, &evlist_base->entries, node) { 615 struct data__file *d; 616 int i; 617 618 data__for_each_file_new(i, d) { 619 struct perf_evlist *evlist = d->session->evlist; 620 struct perf_evsel *evsel; 621 622 evsel = evsel_match(evsel_base, evlist); 623 if (!evsel) 624 continue; 625 626 d->hists = &evsel->hists; 627 628 hists__match(&evsel_base->hists, &evsel->hists); 629 630 if (!show_baseline_only) 631 hists__link(&evsel_base->hists, 632 &evsel->hists); 633 } 634 635 fprintf(stdout, "%s# Event '%s'\n#\n", first ? "" : "\n", 636 perf_evsel__name(evsel_base)); 637 638 first = false; 639 640 if (verbose || data__files_cnt > 2) 641 data__fprintf(); 642 643 hists__process(&evsel_base->hists); 644 } 645 } 646 647 static void data__free(struct data__file *d) 648 { 649 int col; 650 651 for (col = 0; col < PERF_HPP_DIFF__MAX_INDEX; col++) { 652 struct diff_hpp_fmt *fmt = &d->fmt[col]; 653 654 free(fmt->header); 655 } 656 } 657 658 static int __cmd_diff(void) 659 { 660 struct data__file *d; 661 int ret = -EINVAL, i; 662 663 data__for_each_file(i, d) { 664 d->session = perf_session__new(d->file, O_RDONLY, force, 665 false, &tool); 666 if (!d->session) { 667 pr_err("Failed to open %s\n", d->file); 668 ret = -ENOMEM; 669 goto out_delete; 670 } 671 672 ret = perf_session__process_events(d->session, &tool); 673 if (ret) { 674 pr_err("Failed to process %s\n", d->file); 675 goto out_delete; 676 } 677 678 perf_evlist__collapse_resort(d->session->evlist); 679 } 680 681 data_process(); 682 683 out_delete: 684 data__for_each_file(i, d) { 685 if (d->session) 686 perf_session__delete(d->session); 687 688 data__free(d); 689 } 690 691 free(data__files); 692 return ret; 693 } 694 695 static const char * const diff_usage[] = { 696 "perf diff [<options>] [old_file] [new_file]", 697 NULL, 698 }; 699 700 static const struct option options[] = { 701 OPT_INCR('v', "verbose", &verbose, 702 "be more verbose (show symbol address, etc)"), 703 OPT_BOOLEAN('b', "baseline-only", &show_baseline_only, 704 "Show only items with match in baseline"), 705 OPT_CALLBACK('c', "compute", &compute, 706 "delta,ratio,wdiff:w1,w2 (default delta)", 707 "Entries differential computation selection", 708 setup_compute), 709 OPT_BOOLEAN('p', "period", &show_period, 710 "Show period values."), 711 OPT_BOOLEAN('F', "formula", &show_formula, 712 "Show formula."), 713 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, 714 "dump raw trace in ASCII"), 715 OPT_BOOLEAN('f', "force", &force, "don't complain, do it"), 716 OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules, 717 "load module symbols - WARNING: use only with -k and LIVE kernel"), 718 OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]", 719 "only consider symbols in these dsos"), 720 OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]", 721 "only consider symbols in these comms"), 722 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]", 723 "only consider these symbols"), 724 OPT_STRING('s', "sort", &sort_order, "key[,key2...]", 725 "sort by key(s): pid, comm, dso, symbol, parent"), 726 OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator", 727 "separator for columns, no spaces will be added between " 728 "columns '.' is reserved."), 729 OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory", 730 "Look for files with symbols relative to this directory"), 731 OPT_UINTEGER('o', "order", &sort_compute, "Specify compute sorting."), 732 OPT_END() 733 }; 734 735 static double baseline_percent(struct hist_entry *he) 736 { 737 struct hists *hists = he->hists; 738 return 100.0 * he->stat.period / hists->stats.total_period; 739 } 740 741 static int hpp__color_baseline(struct perf_hpp_fmt *fmt, 742 struct perf_hpp *hpp, struct hist_entry *he) 743 { 744 struct diff_hpp_fmt *dfmt = 745 container_of(fmt, struct diff_hpp_fmt, fmt); 746 double percent = baseline_percent(he); 747 char pfmt[20] = " "; 748 749 if (!he->dummy) { 750 scnprintf(pfmt, 20, "%%%d.2f%%%%", dfmt->header_width - 1); 751 return percent_color_snprintf(hpp->buf, hpp->size, 752 pfmt, percent); 753 } else 754 return scnprintf(hpp->buf, hpp->size, "%*s", 755 dfmt->header_width, pfmt); 756 } 757 758 static int hpp__entry_baseline(struct hist_entry *he, char *buf, size_t size) 759 { 760 double percent = baseline_percent(he); 761 const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%"; 762 int ret = 0; 763 764 if (!he->dummy) 765 ret = scnprintf(buf, size, fmt, percent); 766 767 return ret; 768 } 769 770 static void 771 hpp__entry_unpair(struct hist_entry *he, int idx, char *buf, size_t size) 772 { 773 switch (idx) { 774 case PERF_HPP_DIFF__PERIOD_BASELINE: 775 scnprintf(buf, size, "%" PRIu64, he->stat.period); 776 break; 777 778 default: 779 break; 780 } 781 } 782 783 static void 784 hpp__entry_pair(struct hist_entry *he, struct hist_entry *pair, 785 int idx, char *buf, size_t size) 786 { 787 double diff; 788 double ratio; 789 s64 wdiff; 790 791 switch (idx) { 792 case PERF_HPP_DIFF__DELTA: 793 if (pair->diff.computed) 794 diff = pair->diff.period_ratio_delta; 795 else 796 diff = compute_delta(he, pair); 797 798 if (fabs(diff) >= 0.01) 799 scnprintf(buf, size, "%+4.2F%%", diff); 800 break; 801 802 case PERF_HPP_DIFF__RATIO: 803 /* No point for ratio number if we are dummy.. */ 804 if (he->dummy) 805 break; 806 807 if (pair->diff.computed) 808 ratio = pair->diff.period_ratio; 809 else 810 ratio = compute_ratio(he, pair); 811 812 if (ratio > 0.0) 813 scnprintf(buf, size, "%14.6F", ratio); 814 break; 815 816 case PERF_HPP_DIFF__WEIGHTED_DIFF: 817 /* No point for wdiff number if we are dummy.. */ 818 if (he->dummy) 819 break; 820 821 if (pair->diff.computed) 822 wdiff = pair->diff.wdiff; 823 else 824 wdiff = compute_wdiff(he, pair); 825 826 if (wdiff != 0) 827 scnprintf(buf, size, "%14ld", wdiff); 828 break; 829 830 case PERF_HPP_DIFF__FORMULA: 831 formula_fprintf(he, pair, buf, size); 832 break; 833 834 case PERF_HPP_DIFF__PERIOD: 835 scnprintf(buf, size, "%" PRIu64, pair->stat.period); 836 break; 837 838 default: 839 BUG_ON(1); 840 }; 841 } 842 843 static void 844 __hpp__entry_global(struct hist_entry *he, struct diff_hpp_fmt *dfmt, 845 char *buf, size_t size) 846 { 847 struct hist_entry *pair = get_pair_fmt(he, dfmt); 848 int idx = dfmt->idx; 849 850 /* baseline is special */ 851 if (idx == PERF_HPP_DIFF__BASELINE) 852 hpp__entry_baseline(he, buf, size); 853 else { 854 if (pair) 855 hpp__entry_pair(he, pair, idx, buf, size); 856 else 857 hpp__entry_unpair(he, idx, buf, size); 858 } 859 } 860 861 static int hpp__entry_global(struct perf_hpp_fmt *_fmt, struct perf_hpp *hpp, 862 struct hist_entry *he) 863 { 864 struct diff_hpp_fmt *dfmt = 865 container_of(_fmt, struct diff_hpp_fmt, fmt); 866 char buf[MAX_COL_WIDTH] = " "; 867 868 __hpp__entry_global(he, dfmt, buf, MAX_COL_WIDTH); 869 870 if (symbol_conf.field_sep) 871 return scnprintf(hpp->buf, hpp->size, "%s", buf); 872 else 873 return scnprintf(hpp->buf, hpp->size, "%*s", 874 dfmt->header_width, buf); 875 } 876 877 static int hpp__header(struct perf_hpp_fmt *fmt, 878 struct perf_hpp *hpp) 879 { 880 struct diff_hpp_fmt *dfmt = 881 container_of(fmt, struct diff_hpp_fmt, fmt); 882 883 BUG_ON(!dfmt->header); 884 return scnprintf(hpp->buf, hpp->size, dfmt->header); 885 } 886 887 static int hpp__width(struct perf_hpp_fmt *fmt, 888 struct perf_hpp *hpp __maybe_unused) 889 { 890 struct diff_hpp_fmt *dfmt = 891 container_of(fmt, struct diff_hpp_fmt, fmt); 892 893 BUG_ON(dfmt->header_width <= 0); 894 return dfmt->header_width; 895 } 896 897 static void init_header(struct data__file *d, struct diff_hpp_fmt *dfmt) 898 { 899 #define MAX_HEADER_NAME 100 900 char buf_indent[MAX_HEADER_NAME]; 901 char buf[MAX_HEADER_NAME]; 902 const char *header = NULL; 903 int width = 0; 904 905 BUG_ON(dfmt->idx >= PERF_HPP_DIFF__MAX_INDEX); 906 header = columns[dfmt->idx].name; 907 width = columns[dfmt->idx].width; 908 909 /* Only our defined HPP fmts should appear here. */ 910 BUG_ON(!header); 911 912 if (data__files_cnt > 2) 913 scnprintf(buf, MAX_HEADER_NAME, "%s/%d", header, d->idx); 914 915 #define NAME (data__files_cnt > 2 ? buf : header) 916 dfmt->header_width = width; 917 width = (int) strlen(NAME); 918 if (dfmt->header_width < width) 919 dfmt->header_width = width; 920 921 scnprintf(buf_indent, MAX_HEADER_NAME, "%*s", 922 dfmt->header_width, NAME); 923 924 dfmt->header = strdup(buf_indent); 925 #undef MAX_HEADER_NAME 926 #undef NAME 927 } 928 929 static void data__hpp_register(struct data__file *d, int idx) 930 { 931 struct diff_hpp_fmt *dfmt = &d->fmt[idx]; 932 struct perf_hpp_fmt *fmt = &dfmt->fmt; 933 934 dfmt->idx = idx; 935 936 fmt->header = hpp__header; 937 fmt->width = hpp__width; 938 fmt->entry = hpp__entry_global; 939 940 /* TODO more colors */ 941 if (idx == PERF_HPP_DIFF__BASELINE) 942 fmt->color = hpp__color_baseline; 943 944 init_header(d, dfmt); 945 perf_hpp__column_register(fmt); 946 } 947 948 static void ui_init(void) 949 { 950 struct data__file *d; 951 int i; 952 953 data__for_each_file(i, d) { 954 955 /* 956 * Baseline or compute realted columns: 957 * 958 * PERF_HPP_DIFF__BASELINE 959 * PERF_HPP_DIFF__DELTA 960 * PERF_HPP_DIFF__RATIO 961 * PERF_HPP_DIFF__WEIGHTED_DIFF 962 */ 963 data__hpp_register(d, i ? compute_2_hpp[compute] : 964 PERF_HPP_DIFF__BASELINE); 965 966 /* 967 * And the rest: 968 * 969 * PERF_HPP_DIFF__FORMULA 970 * PERF_HPP_DIFF__PERIOD 971 * PERF_HPP_DIFF__PERIOD_BASELINE 972 */ 973 if (show_formula && i) 974 data__hpp_register(d, PERF_HPP_DIFF__FORMULA); 975 976 if (show_period) 977 data__hpp_register(d, i ? PERF_HPP_DIFF__PERIOD : 978 PERF_HPP_DIFF__PERIOD_BASELINE); 979 } 980 } 981 982 static int data_init(int argc, const char **argv) 983 { 984 struct data__file *d; 985 static const char *defaults[] = { 986 "perf.data.old", 987 "perf.data", 988 }; 989 bool use_default = true; 990 int i; 991 992 data__files_cnt = 2; 993 994 if (argc) { 995 if (argc == 1) 996 defaults[1] = argv[0]; 997 else { 998 data__files_cnt = argc; 999 use_default = false; 1000 } 1001 } else if (symbol_conf.default_guest_vmlinux_name || 1002 symbol_conf.default_guest_kallsyms) { 1003 defaults[0] = "perf.data.host"; 1004 defaults[1] = "perf.data.guest"; 1005 } 1006 1007 if (sort_compute >= (unsigned int) data__files_cnt) { 1008 pr_err("Order option out of limit.\n"); 1009 return -EINVAL; 1010 } 1011 1012 data__files = zalloc(sizeof(*data__files) * data__files_cnt); 1013 if (!data__files) 1014 return -ENOMEM; 1015 1016 data__for_each_file(i, d) { 1017 d->file = use_default ? defaults[i] : argv[i]; 1018 d->idx = i; 1019 } 1020 1021 return 0; 1022 } 1023 1024 int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused) 1025 { 1026 sort_order = diff__default_sort_order; 1027 argc = parse_options(argc, argv, options, diff_usage, 0); 1028 1029 if (symbol__init() < 0) 1030 return -1; 1031 1032 if (data_init(argc, argv) < 0) 1033 return -1; 1034 1035 ui_init(); 1036 1037 if (setup_sorting() < 0) 1038 usage_with_options(diff_usage, options); 1039 1040 setup_pager(); 1041 1042 sort__setup_elide(NULL); 1043 1044 return __cmd_diff(); 1045 } 1046
