tools/perf/builtin-diff.c

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