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 22 static char const *input_old = "perf.data.old", 23 *input_new = "perf.data"; 24 static char diff__default_sort_order[] = "dso,symbol"; 25 static bool force; 26 static bool show_period; 27 static bool show_formula; 28 static bool show_baseline_only; 29 static bool sort_compute; 30 31 static s64 compute_wdiff_w1; 32 static s64 compute_wdiff_w2; 33 34 enum { 35 COMPUTE_DELTA, 36 COMPUTE_RATIO, 37 COMPUTE_WEIGHTED_DIFF, 38 COMPUTE_MAX, 39 }; 40 41 const char *compute_names[COMPUTE_MAX] = { 42 [COMPUTE_DELTA] = "delta", 43 [COMPUTE_RATIO] = "ratio", 44 [COMPUTE_WEIGHTED_DIFF] = "wdiff", 45 }; 46 47 static int compute; 48 49 static int setup_compute_opt_wdiff(char *opt) 50 { 51 char *w1_str = opt; 52 char *w2_str; 53 54 int ret = -EINVAL; 55 56 if (!opt) 57 goto out; 58 59 w2_str = strchr(opt, ','); 60 if (!w2_str) 61 goto out; 62 63 *w2_str++ = 0x0; 64 if (!*w2_str) 65 goto out; 66 67 compute_wdiff_w1 = strtol(w1_str, NULL, 10); 68 compute_wdiff_w2 = strtol(w2_str, NULL, 10); 69 70 if (!compute_wdiff_w1 || !compute_wdiff_w2) 71 goto out; 72 73 pr_debug("compute wdiff w1(%" PRId64 ") w2(%" PRId64 ")\n", 74 compute_wdiff_w1, compute_wdiff_w2); 75 76 ret = 0; 77 78 out: 79 if (ret) 80 pr_err("Failed: wrong weight data, use 'wdiff:w1,w2'\n"); 81 82 return ret; 83 } 84 85 static int setup_compute_opt(char *opt) 86 { 87 if (compute == COMPUTE_WEIGHTED_DIFF) 88 return setup_compute_opt_wdiff(opt); 89 90 if (opt) { 91 pr_err("Failed: extra option specified '%s'", opt); 92 return -EINVAL; 93 } 94 95 return 0; 96 } 97 98 static int setup_compute(const struct option *opt, const char *str, 99 int unset __maybe_unused) 100 { 101 int *cp = (int *) opt->value; 102 char *cstr = (char *) str; 103 char buf[50]; 104 unsigned i; 105 char *option; 106 107 if (!str) { 108 *cp = COMPUTE_DELTA; 109 return 0; 110 } 111 112 if (*str == '+') { 113 sort_compute = true; 114 cstr = (char *) ++str; 115 if (!*str) 116 return 0; 117 } 118 119 option = strchr(str, ':'); 120 if (option) { 121 unsigned len = option++ - str; 122 123 /* 124 * The str data are not writeable, so we need 125 * to use another buffer. 126 */ 127 128 /* No option value is longer. */ 129 if (len >= sizeof(buf)) 130 return -EINVAL; 131 132 strncpy(buf, str, len); 133 buf[len] = 0x0; 134 cstr = buf; 135 } 136 137 for (i = 0; i < COMPUTE_MAX; i++) 138 if (!strcmp(cstr, compute_names[i])) { 139 *cp = i; 140 return setup_compute_opt(option); 141 } 142 143 pr_err("Failed: '%s' is not computation method " 144 "(use 'delta','ratio' or 'wdiff')\n", str); 145 return -EINVAL; 146 } 147 148 double perf_diff__period_percent(struct hist_entry *he, u64 period) 149 { 150 u64 total = he->hists->stats.total_period; 151 return (period * 100.0) / total; 152 } 153 154 double perf_diff__compute_delta(struct hist_entry *he, struct hist_entry *pair) 155 { 156 double new_percent = perf_diff__period_percent(he, he->stat.period); 157 double old_percent = perf_diff__period_percent(pair, pair->stat.period); 158 159 he->diff.period_ratio_delta = new_percent - old_percent; 160 he->diff.computed = true; 161 return he->diff.period_ratio_delta; 162 } 163 164 double perf_diff__compute_ratio(struct hist_entry *he, struct hist_entry *pair) 165 { 166 double new_period = he->stat.period; 167 double old_period = pair->stat.period; 168 169 he->diff.computed = true; 170 he->diff.period_ratio = new_period / old_period; 171 return he->diff.period_ratio; 172 } 173 174 s64 perf_diff__compute_wdiff(struct hist_entry *he, struct hist_entry *pair) 175 { 176 u64 new_period = he->stat.period; 177 u64 old_period = pair->stat.period; 178 179 he->diff.computed = true; 180 he->diff.wdiff = new_period * compute_wdiff_w2 - 181 old_period * compute_wdiff_w1; 182 183 return he->diff.wdiff; 184 } 185 186 static int formula_delta(struct hist_entry *he, struct hist_entry *pair, 187 char *buf, size_t size) 188 { 189 return scnprintf(buf, size, 190 "(%" PRIu64 " * 100 / %" PRIu64 ") - " 191 "(%" PRIu64 " * 100 / %" PRIu64 ")", 192 he->stat.period, he->hists->stats.total_period, 193 pair->stat.period, pair->hists->stats.total_period); 194 } 195 196 static int formula_ratio(struct hist_entry *he, struct hist_entry *pair, 197 char *buf, size_t size) 198 { 199 double new_period = he->stat.period; 200 double old_period = pair->stat.period; 201 202 return scnprintf(buf, size, "%.0F / %.0F", new_period, old_period); 203 } 204 205 static int formula_wdiff(struct hist_entry *he, struct hist_entry *pair, 206 char *buf, size_t size) 207 { 208 u64 new_period = he->stat.period; 209 u64 old_period = pair->stat.period; 210 211 return scnprintf(buf, size, 212 "(%" PRIu64 " * " "%" PRId64 ") - (%" PRIu64 " * " "%" PRId64 ")", 213 new_period, compute_wdiff_w2, old_period, compute_wdiff_w1); 214 } 215 216 int perf_diff__formula(struct hist_entry *he, struct hist_entry *pair, 217 char *buf, size_t size) 218 { 219 switch (compute) { 220 case COMPUTE_DELTA: 221 return formula_delta(he, pair, buf, size); 222 case COMPUTE_RATIO: 223 return formula_ratio(he, pair, buf, size); 224 case COMPUTE_WEIGHTED_DIFF: 225 return formula_wdiff(he, pair, buf, size); 226 default: 227 BUG_ON(1); 228 } 229 230 return -1; 231 } 232 233 static int hists__add_entry(struct hists *self, 234 struct addr_location *al, u64 period) 235 { 236 if (__hists__add_entry(self, al, NULL, period) != NULL) 237 return 0; 238 return -ENOMEM; 239 } 240 241 static int diff__process_sample_event(struct perf_tool *tool __maybe_unused, 242 union perf_event *event, 243 struct perf_sample *sample, 244 struct perf_evsel *evsel, 245 struct machine *machine) 246 { 247 struct addr_location al; 248 249 if (perf_event__preprocess_sample(event, machine, &al, sample, NULL) < 0) { 250 pr_warning("problem processing %d event, skipping it.\n", 251 event->header.type); 252 return -1; 253 } 254 255 if (al.filtered) 256 return 0; 257 258 if (hists__add_entry(&evsel->hists, &al, sample->period)) { 259 pr_warning("problem incrementing symbol period, skipping event\n"); 260 return -1; 261 } 262 263 evsel->hists.stats.total_period += sample->period; 264 return 0; 265 } 266 267 static struct perf_tool tool = { 268 .sample = diff__process_sample_event, 269 .mmap = perf_event__process_mmap, 270 .comm = perf_event__process_comm, 271 .exit = perf_event__process_exit, 272 .fork = perf_event__process_fork, 273 .lost = perf_event__process_lost, 274 .ordered_samples = true, 275 .ordering_requires_timestamps = true, 276 }; 277 278 static struct perf_evsel *evsel_match(struct perf_evsel *evsel, 279 struct perf_evlist *evlist) 280 { 281 struct perf_evsel *e; 282 283 list_for_each_entry(e, &evlist->entries, node) 284 if (perf_evsel__match2(evsel, e)) 285 return e; 286 287 return NULL; 288 } 289 290 static void perf_evlist__collapse_resort(struct perf_evlist *evlist) 291 { 292 struct perf_evsel *evsel; 293 294 list_for_each_entry(evsel, &evlist->entries, node) { 295 struct hists *hists = &evsel->hists; 296 297 hists__collapse_resort(hists); 298 } 299 } 300 301 static void hists__baseline_only(struct hists *hists) 302 { 303 struct rb_root *root; 304 struct rb_node *next; 305 306 if (sort__need_collapse) 307 root = &hists->entries_collapsed; 308 else 309 root = hists->entries_in; 310 311 next = rb_first(root); 312 while (next != NULL) { 313 struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in); 314 315 next = rb_next(&he->rb_node_in); 316 if (!hist_entry__next_pair(he)) { 317 rb_erase(&he->rb_node_in, root); 318 hist_entry__free(he); 319 } 320 } 321 } 322 323 static void hists__precompute(struct hists *hists) 324 { 325 struct rb_node *next = rb_first(&hists->entries); 326 327 while (next != NULL) { 328 struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node); 329 struct hist_entry *pair = hist_entry__next_pair(he); 330 331 next = rb_next(&he->rb_node); 332 if (!pair) 333 continue; 334 335 switch (compute) { 336 case COMPUTE_DELTA: 337 perf_diff__compute_delta(he, pair); 338 break; 339 case COMPUTE_RATIO: 340 perf_diff__compute_ratio(he, pair); 341 break; 342 case COMPUTE_WEIGHTED_DIFF: 343 perf_diff__compute_wdiff(he, pair); 344 break; 345 default: 346 BUG_ON(1); 347 } 348 } 349 } 350 351 static int64_t cmp_doubles(double l, double r) 352 { 353 if (l > r) 354 return -1; 355 else if (l < r) 356 return 1; 357 else 358 return 0; 359 } 360 361 static int64_t 362 hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right, 363 int c) 364 { 365 switch (c) { 366 case COMPUTE_DELTA: 367 { 368 double l = left->diff.period_ratio_delta; 369 double r = right->diff.period_ratio_delta; 370 371 return cmp_doubles(l, r); 372 } 373 case COMPUTE_RATIO: 374 { 375 double l = left->diff.period_ratio; 376 double r = right->diff.period_ratio; 377 378 return cmp_doubles(l, r); 379 } 380 case COMPUTE_WEIGHTED_DIFF: 381 { 382 s64 l = left->diff.wdiff; 383 s64 r = right->diff.wdiff; 384 385 return r - l; 386 } 387 default: 388 BUG_ON(1); 389 } 390 391 return 0; 392 } 393 394 static void insert_hist_entry_by_compute(struct rb_root *root, 395 struct hist_entry *he, 396 int c) 397 { 398 struct rb_node **p = &root->rb_node; 399 struct rb_node *parent = NULL; 400 struct hist_entry *iter; 401 402 while (*p != NULL) { 403 parent = *p; 404 iter = rb_entry(parent, struct hist_entry, rb_node); 405 if (hist_entry__cmp_compute(he, iter, c) < 0) 406 p = &(*p)->rb_left; 407 else 408 p = &(*p)->rb_right; 409 } 410 411 rb_link_node(&he->rb_node, parent, p); 412 rb_insert_color(&he->rb_node, root); 413 } 414 415 static void hists__compute_resort(struct hists *hists) 416 { 417 struct rb_root *root; 418 struct rb_node *next; 419 420 if (sort__need_collapse) 421 root = &hists->entries_collapsed; 422 else 423 root = hists->entries_in; 424 425 hists->entries = RB_ROOT; 426 next = rb_first(root); 427 428 hists->nr_entries = 0; 429 hists->stats.total_period = 0; 430 hists__reset_col_len(hists); 431 432 while (next != NULL) { 433 struct hist_entry *he; 434 435 he = rb_entry(next, struct hist_entry, rb_node_in); 436 next = rb_next(&he->rb_node_in); 437 438 insert_hist_entry_by_compute(&hists->entries, he, compute); 439 hists__inc_nr_entries(hists, he); 440 } 441 } 442 443 static void hists__process(struct hists *old, struct hists *new) 444 { 445 hists__match(new, old); 446 447 if (show_baseline_only) 448 hists__baseline_only(new); 449 else 450 hists__link(new, old); 451 452 if (sort_compute) { 453 hists__precompute(new); 454 hists__compute_resort(new); 455 } else { 456 hists__output_resort(new); 457 } 458 459 hists__fprintf(new, true, 0, 0, stdout); 460 } 461 462 static int __cmd_diff(void) 463 { 464 int ret, i; 465 #define older (session[0]) 466 #define newer (session[1]) 467 struct perf_session *session[2]; 468 struct perf_evlist *evlist_new, *evlist_old; 469 struct perf_evsel *evsel; 470 bool first = true; 471 472 older = perf_session__new(input_old, O_RDONLY, force, false, 473 &tool); 474 newer = perf_session__new(input_new, O_RDONLY, force, false, 475 &tool); 476 if (session[0] == NULL || session[1] == NULL) 477 return -ENOMEM; 478 479 for (i = 0; i < 2; ++i) { 480 ret = perf_session__process_events(session[i], &tool); 481 if (ret) 482 goto out_delete; 483 } 484 485 evlist_old = older->evlist; 486 evlist_new = newer->evlist; 487 488 perf_evlist__collapse_resort(evlist_old); 489 perf_evlist__collapse_resort(evlist_new); 490 491 list_for_each_entry(evsel, &evlist_new->entries, node) { 492 struct perf_evsel *evsel_old; 493 494 evsel_old = evsel_match(evsel, evlist_old); 495 if (!evsel_old) 496 continue; 497 498 fprintf(stdout, "%s# Event '%s'\n#\n", first ? "" : "\n", 499 perf_evsel__name(evsel)); 500 501 first = false; 502 503 hists__process(&evsel_old->hists, &evsel->hists); 504 } 505 506 out_delete: 507 for (i = 0; i < 2; ++i) 508 perf_session__delete(session[i]); 509 return ret; 510 #undef older 511 #undef newer 512 } 513 514 static const char * const diff_usage[] = { 515 "perf diff [<options>] [old_file] [new_file]", 516 NULL, 517 }; 518 519 static const struct option options[] = { 520 OPT_INCR('v', "verbose", &verbose, 521 "be more verbose (show symbol address, etc)"), 522 OPT_BOOLEAN('b', "baseline-only", &show_baseline_only, 523 "Show only items with match in baseline"), 524 OPT_CALLBACK('c', "compute", &compute, 525 "delta,ratio,wdiff:w1,w2 (default delta)", 526 "Entries differential computation selection", 527 setup_compute), 528 OPT_BOOLEAN('p', "period", &show_period, 529 "Show period values."), 530 OPT_BOOLEAN('F', "formula", &show_formula, 531 "Show formula."), 532 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, 533 "dump raw trace in ASCII"), 534 OPT_BOOLEAN('f', "force", &force, "don't complain, do it"), 535 OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules, 536 "load module symbols - WARNING: use only with -k and LIVE kernel"), 537 OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]", 538 "only consider symbols in these dsos"), 539 OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]", 540 "only consider symbols in these comms"), 541 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]", 542 "only consider these symbols"), 543 OPT_STRING('s', "sort", &sort_order, "key[,key2...]", 544 "sort by key(s): pid, comm, dso, symbol, parent"), 545 OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator", 546 "separator for columns, no spaces will be added between " 547 "columns '.' is reserved."), 548 OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory", 549 "Look for files with symbols relative to this directory"), 550 OPT_END() 551 }; 552 553 static void ui_init(void) 554 { 555 /* 556 * Display baseline/delta/ratio 557 * formula/periods columns. 558 */ 559 perf_hpp__column_enable(PERF_HPP__BASELINE); 560 561 switch (compute) { 562 case COMPUTE_DELTA: 563 perf_hpp__column_enable(PERF_HPP__DELTA); 564 break; 565 case COMPUTE_RATIO: 566 perf_hpp__column_enable(PERF_HPP__RATIO); 567 break; 568 case COMPUTE_WEIGHTED_DIFF: 569 perf_hpp__column_enable(PERF_HPP__WEIGHTED_DIFF); 570 break; 571 default: 572 BUG_ON(1); 573 }; 574 575 if (show_formula) 576 perf_hpp__column_enable(PERF_HPP__FORMULA); 577 578 if (show_period) { 579 perf_hpp__column_enable(PERF_HPP__PERIOD); 580 perf_hpp__column_enable(PERF_HPP__PERIOD_BASELINE); 581 } 582 } 583 584 int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused) 585 { 586 sort_order = diff__default_sort_order; 587 argc = parse_options(argc, argv, options, diff_usage, 0); 588 if (argc) { 589 if (argc > 2) 590 usage_with_options(diff_usage, options); 591 if (argc == 2) { 592 input_old = argv[0]; 593 input_new = argv[1]; 594 } else 595 input_new = argv[0]; 596 } else if (symbol_conf.default_guest_vmlinux_name || 597 symbol_conf.default_guest_kallsyms) { 598 input_old = "perf.data.host"; 599 input_new = "perf.data.guest"; 600 } 601 602 symbol_conf.exclude_other = false; 603 if (symbol__init() < 0) 604 return -1; 605 606 ui_init(); 607 608 if (setup_sorting() < 0) 609 usage_with_options(diff_usage, options); 610 611 setup_pager(); 612 613 sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", NULL); 614 sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", NULL); 615 sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", NULL); 616 617 return __cmd_diff(); 618 } 619