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