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