tools/perf/builtin-diff.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * builtin-diff.c
   4  *
   5  * Builtin diff command: Analyze two perf.data input files, look up and read
   6  * DSOs and symbol information, sort them and produce a diff.
   7  */
   8 #include "builtin.h"
   9 #include "perf.h"
  10
  11 #include "util/debug.h"
  12 #include "util/event.h"
  13 #include "util/hist.h"
  14 #include "util/evsel.h"
  15 #include "util/evlist.h"
  16 #include "util/session.h"
  17 #include "util/tool.h"
  18 #include "util/sort.h"
  19 #include "util/srcline.h"
  20 #include "util/symbol.h"
  21 #include "util/data.h"
  22 #include "util/config.h"
  23 #include "util/time-utils.h"
  24 #include "util/annotate.h"
  25 #include "util/map.h"
  26 #include <linux/err.h>
  27 #include <linux/zalloc.h>
  28 #include <subcmd/pager.h>
  29 #include <subcmd/parse-options.h>
  30
  31 #include <errno.h>
  32 #include <inttypes.h>
  33 #include <stdlib.h>
  34 #include <math.h>
  35
  36 struct perf_diff {
  37         struct perf_tool                 tool;
  38         const char                      *time_str;
  39         struct perf_time_interval       *ptime_range;
  40         int                              range_size;
  41         int                              range_num;
  42         bool                             has_br_stack;
  43 };
  44
  45 /* Diff command specific HPP columns. */
  46 enum {
  47         PERF_HPP_DIFF__BASELINE,
  48         PERF_HPP_DIFF__PERIOD,
  49         PERF_HPP_DIFF__PERIOD_BASELINE,
  50         PERF_HPP_DIFF__DELTA,
  51         PERF_HPP_DIFF__RATIO,
  52         PERF_HPP_DIFF__WEIGHTED_DIFF,
  53         PERF_HPP_DIFF__FORMULA,
  54         PERF_HPP_DIFF__DELTA_ABS,
  55         PERF_HPP_DIFF__CYCLES,
  56
  57         PERF_HPP_DIFF__MAX_INDEX
  58 };
  59
  60 struct diff_hpp_fmt {
  61         struct perf_hpp_fmt      fmt;
  62         int                      idx;
  63         char                    *header;
  64         int                      header_width;
  65 };
  66
  67 struct data__file {
  68         struct perf_session     *session;
  69         struct perf_data         data;
  70         int                      idx;
  71         struct hists            *hists;
  72         struct diff_hpp_fmt      fmt[PERF_HPP_DIFF__MAX_INDEX];
  73 };
  74
  75 static struct data__file *data__files;
  76 static int data__files_cnt;
  77
  78 #define data__for_each_file_start(i, d, s)      \
  79         for (i = s, d = &data__files[s];        \
  80              i < data__files_cnt;               \
  81              i++, d = &data__files[i])
  82
  83 #define data__for_each_file(i, d) data__for_each_file_start(i, d, 0)
  84 #define data__for_each_file_new(i, d) data__for_each_file_start(i, d, 1)
  85
  86 static bool force;
  87 static bool show_period;
  88 static bool show_formula;
  89 static bool show_baseline_only;
  90 static unsigned int sort_compute = 1;
  91
  92 static s64 compute_wdiff_w1;
  93 static s64 compute_wdiff_w2;
  94
  95 static const char               *cpu_list;
  96 static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
  97
  98 static struct addr_location dummy_al;
  99
 100 enum {
 101         COMPUTE_DELTA,
 102         COMPUTE_RATIO,
 103         COMPUTE_WEIGHTED_DIFF,
 104         COMPUTE_DELTA_ABS,
 105         COMPUTE_CYCLES,
 106         COMPUTE_MAX,
 107 };
 108
 109 const char *compute_names[COMPUTE_MAX] = {
 110         [COMPUTE_DELTA] = "delta",
 111         [COMPUTE_DELTA_ABS] = "delta-abs",
 112         [COMPUTE_RATIO] = "ratio",
 113         [COMPUTE_WEIGHTED_DIFF] = "wdiff",
 114         [COMPUTE_CYCLES] = "cycles",
 115 };
 116
 117 static int compute = COMPUTE_DELTA_ABS;
 118
 119 static int compute_2_hpp[COMPUTE_MAX] = {
 120         [COMPUTE_DELTA]         = PERF_HPP_DIFF__DELTA,
 121         [COMPUTE_DELTA_ABS]     = PERF_HPP_DIFF__DELTA_ABS,
 122         [COMPUTE_RATIO]         = PERF_HPP_DIFF__RATIO,
 123         [COMPUTE_WEIGHTED_DIFF] = PERF_HPP_DIFF__WEIGHTED_DIFF,
 124         [COMPUTE_CYCLES]        = PERF_HPP_DIFF__CYCLES,
 125 };
 126
 127 #define MAX_COL_WIDTH 70
 128
 129 static struct header_column {
 130         const char *name;
 131         int width;
 132 } columns[PERF_HPP_DIFF__MAX_INDEX] = {
 133         [PERF_HPP_DIFF__BASELINE] = {
 134                 .name  = "Baseline",
 135         },
 136         [PERF_HPP_DIFF__PERIOD] = {
 137                 .name  = "Period",
 138                 .width = 14,
 139         },
 140         [PERF_HPP_DIFF__PERIOD_BASELINE] = {
 141                 .name  = "Base period",
 142                 .width = 14,
 143         },
 144         [PERF_HPP_DIFF__DELTA] = {
 145                 .name  = "Delta",
 146                 .width = 7,
 147         },
 148         [PERF_HPP_DIFF__DELTA_ABS] = {
 149                 .name  = "Delta Abs",
 150                 .width = 7,
 151         },
 152         [PERF_HPP_DIFF__RATIO] = {
 153                 .name  = "Ratio",
 154                 .width = 14,
 155         },
 156         [PERF_HPP_DIFF__WEIGHTED_DIFF] = {
 157                 .name  = "Weighted diff",
 158                 .width = 14,
 159         },
 160         [PERF_HPP_DIFF__FORMULA] = {
 161                 .name  = "Formula",
 162                 .width = MAX_COL_WIDTH,
 163         },
 164         [PERF_HPP_DIFF__CYCLES] = {
 165                 .name  = "[Program Block Range] Cycles Diff",
 166                 .width = 70,
 167         }
 168 };
 169
 170 static int setup_compute_opt_wdiff(char *opt)
 171 {
 172         char *w1_str = opt;
 173         char *w2_str;
 174
 175         int ret = -EINVAL;
 176
 177         if (!opt)
 178                 goto out;
 179
 180         w2_str = strchr(opt, ',');
 181         if (!w2_str)
 182                 goto out;
 183
 184         *w2_str++ = 0x0;
 185         if (!*w2_str)
 186                 goto out;
 187
 188         compute_wdiff_w1 = strtol(w1_str, NULL, 10);
 189         compute_wdiff_w2 = strtol(w2_str, NULL, 10);
 190
 191         if (!compute_wdiff_w1 || !compute_wdiff_w2)
 192                 goto out;
 193
 194         pr_debug("compute wdiff w1(%" PRId64 ") w2(%" PRId64 ")\n",
 195                   compute_wdiff_w1, compute_wdiff_w2);
 196
 197         ret = 0;
 198
 199  out:
 200         if (ret)
 201                 pr_err("Failed: wrong weight data, use 'wdiff:w1,w2'\n");
 202
 203         return ret;
 204 }
 205
 206 static int setup_compute_opt(char *opt)
 207 {
 208         if (compute == COMPUTE_WEIGHTED_DIFF)
 209                 return setup_compute_opt_wdiff(opt);
 210
 211         if (opt) {
 212                 pr_err("Failed: extra option specified '%s'", opt);
 213                 return -EINVAL;
 214         }
 215
 216         return 0;
 217 }
 218
 219 static int setup_compute(const struct option *opt, const char *str,
 220                          int unset __maybe_unused)
 221 {
 222         int *cp = (int *) opt->value;
 223         char *cstr = (char *) str;
 224         char buf[50];
 225         unsigned i;
 226         char *option;
 227
 228         if (!str) {
 229                 *cp = COMPUTE_DELTA;
 230                 return 0;
 231         }
 232
 233         option = strchr(str, ':');
 234         if (option) {
 235                 unsigned len = option++ - str;
 236
 237                 /*
 238                  * The str data are not writeable, so we need
 239                  * to use another buffer.
 240                  */
 241
 242                 /* No option value is longer. */
 243                 if (len >= sizeof(buf))
 244                         return -EINVAL;
 245
 246                 strncpy(buf, str, len);
 247                 buf[len] = 0x0;
 248                 cstr = buf;
 249         }
 250
 251         for (i = 0; i < COMPUTE_MAX; i++)
 252                 if (!strcmp(cstr, compute_names[i])) {
 253                         *cp = i;
 254                         return setup_compute_opt(option);
 255                 }
 256
 257         pr_err("Failed: '%s' is not computation method "
 258                "(use 'delta','ratio' or 'wdiff')\n", str);
 259         return -EINVAL;
 260 }
 261
 262 static double period_percent(struct hist_entry *he, u64 period)
 263 {
 264         u64 total = hists__total_period(he->hists);
 265
 266         return (period * 100.0) / total;
 267 }
 268
 269 static double compute_delta(struct hist_entry *he, struct hist_entry *pair)
 270 {
 271         double old_percent = period_percent(he, he->stat.period);
 272         double new_percent = period_percent(pair, pair->stat.period);
 273
 274         pair->diff.period_ratio_delta = new_percent - old_percent;
 275         pair->diff.computed = true;
 276         return pair->diff.period_ratio_delta;
 277 }
 278
 279 static double compute_ratio(struct hist_entry *he, struct hist_entry *pair)
 280 {
 281         double old_period = he->stat.period ?: 1;
 282         double new_period = pair->stat.period;
 283
 284         pair->diff.computed = true;
 285         pair->diff.period_ratio = new_period / old_period;
 286         return pair->diff.period_ratio;
 287 }
 288
 289 static s64 compute_wdiff(struct hist_entry *he, struct hist_entry *pair)
 290 {
 291         u64 old_period = he->stat.period;
 292         u64 new_period = pair->stat.period;
 293
 294         pair->diff.computed = true;
 295         pair->diff.wdiff = new_period * compute_wdiff_w2 -
 296                            old_period * compute_wdiff_w1;
 297
 298         return pair->diff.wdiff;
 299 }
 300
 301 static int formula_delta(struct hist_entry *he, struct hist_entry *pair,
 302                          char *buf, size_t size)
 303 {
 304         u64 he_total = he->hists->stats.total_period;
 305         u64 pair_total = pair->hists->stats.total_period;
 306
 307         if (symbol_conf.filter_relative) {
 308                 he_total = he->hists->stats.total_non_filtered_period;
 309                 pair_total = pair->hists->stats.total_non_filtered_period;
 310         }
 311         return scnprintf(buf, size,
 312                          "(%" PRIu64 " * 100 / %" PRIu64 ") - "
 313                          "(%" PRIu64 " * 100 / %" PRIu64 ")",
 314                          pair->stat.period, pair_total,
 315                          he->stat.period, he_total);
 316 }
 317
 318 static int formula_ratio(struct hist_entry *he, struct hist_entry *pair,
 319                          char *buf, size_t size)
 320 {
 321         double old_period = he->stat.period;
 322         double new_period = pair->stat.period;
 323
 324         return scnprintf(buf, size, "%.0F / %.0F", new_period, old_period);
 325 }
 326
 327 static int formula_wdiff(struct hist_entry *he, struct hist_entry *pair,
 328                          char *buf, size_t size)
 329 {
 330         u64 old_period = he->stat.period;
 331         u64 new_period = pair->stat.period;
 332
 333         return scnprintf(buf, size,
 334                   "(%" PRIu64 " * " "%" PRId64 ") - (%" PRIu64 " * " "%" PRId64 ")",
 335                   new_period, compute_wdiff_w2, old_period, compute_wdiff_w1);
 336 }
 337
 338 static int formula_fprintf(struct hist_entry *he, struct hist_entry *pair,
 339                            char *buf, size_t size)
 340 {
 341         switch (compute) {
 342         case COMPUTE_DELTA:
 343         case COMPUTE_DELTA_ABS:
 344                 return formula_delta(he, pair, buf, size);
 345         case COMPUTE_RATIO:
 346                 return formula_ratio(he, pair, buf, size);
 347         case COMPUTE_WEIGHTED_DIFF:
 348                 return formula_wdiff(he, pair, buf, size);
 349         default:
 350                 BUG_ON(1);
 351         }
 352
 353         return -1;
 354 }
 355
 356 static void *block_hist_zalloc(size_t size)
 357 {
 358         struct block_hist *bh;
 359
 360         bh = zalloc(size + sizeof(*bh));
 361         if (!bh)
 362                 return NULL;
 363
 364         return &bh->he;
 365 }
 366
 367 static void block_hist_free(void *he)
 368 {
 369         struct block_hist *bh;
 370
 371         bh = container_of(he, struct block_hist, he);
 372         hists__delete_entries(&bh->block_hists);
 373         free(bh);
 374 }
 375
 376 struct hist_entry_ops block_hist_ops = {
 377         .new    = block_hist_zalloc,
 378         .free   = block_hist_free,
 379 };
 380
 381 static int diff__process_sample_event(struct perf_tool *tool,
 382                                       union perf_event *event,
 383                                       struct perf_sample *sample,
 384                                       struct evsel *evsel,
 385                                       struct machine *machine)
 386 {
 387         struct perf_diff *pdiff = container_of(tool, struct perf_diff, tool);
 388         struct addr_location al;
 389         struct hists *hists = evsel__hists(evsel);
 390         int ret = -1;
 391
 392         if (perf_time__ranges_skip_sample(pdiff->ptime_range, pdiff->range_num,
 393                                           sample->time)) {
 394                 return 0;
 395         }
 396
 397         if (machine__resolve(machine, &al, sample) < 0) {
 398                 pr_warning("problem processing %d event, skipping it.\n",
 399                            event->header.type);
 400                 return -1;
 401         }
 402
 403         if (cpu_list && !test_bit(sample->cpu, cpu_bitmap)) {
 404                 ret = 0;
 405                 goto out_put;
 406         }
 407
 408         if (compute != COMPUTE_CYCLES) {
 409                 if (!hists__add_entry(hists, &al, NULL, NULL, NULL, sample,
 410                                       true)) {
 411                         pr_warning("problem incrementing symbol period, "
 412                                    "skipping event\n");
 413                         goto out_put;
 414                 }
 415         } else {
 416                 if (!hists__add_entry_ops(hists, &block_hist_ops, &al, NULL,
 417                                           NULL, NULL, sample, true)) {
 418                         pr_warning("problem incrementing symbol period, "
 419                                    "skipping event\n");
 420                         goto out_put;
 421                 }
 422
 423                 hist__account_cycles(sample->branch_stack, &al, sample, false);
 424         }
 425
 426         /*
 427          * The total_period is updated here before going to the output
 428          * tree since normally only the baseline hists will call
 429          * hists__output_resort() and precompute needs the total
 430          * period in order to sort entries by percentage delta.
 431          */
 432         hists->stats.total_period += sample->period;
 433         if (!al.filtered)
 434                 hists->stats.total_non_filtered_period += sample->period;
 435         ret = 0;
 436 out_put:
 437         addr_location__put(&al);
 438         return ret;
 439 }
 440
 441 static struct perf_diff pdiff = {
 442         .tool = {
 443                 .sample = diff__process_sample_event,
 444                 .mmap   = perf_event__process_mmap,
 445                 .mmap2  = perf_event__process_mmap2,
 446                 .comm   = perf_event__process_comm,
 447                 .exit   = perf_event__process_exit,
 448                 .fork   = perf_event__process_fork,
 449                 .lost   = perf_event__process_lost,
 450                 .namespaces = perf_event__process_namespaces,
 451                 .ordered_events = true,
 452                 .ordering_requires_timestamps = true,
 453         },
 454 };
 455
 456 static struct evsel *evsel_match(struct evsel *evsel,
 457                                       struct evlist *evlist)
 458 {
 459         struct evsel *e;
 460
 461         evlist__for_each_entry(evlist, e) {
 462                 if (perf_evsel__match2(evsel, e))
 463                         return e;
 464         }
 465
 466         return NULL;
 467 }
 468
 469 static void perf_evlist__collapse_resort(struct evlist *evlist)
 470 {
 471         struct evsel *evsel;
 472
 473         evlist__for_each_entry(evlist, evsel) {
 474                 struct hists *hists = evsel__hists(evsel);
 475
 476                 hists__collapse_resort(hists, NULL);
 477         }
 478 }
 479
 480 static struct data__file *fmt_to_data_file(struct perf_hpp_fmt *fmt)
 481 {
 482         struct diff_hpp_fmt *dfmt = container_of(fmt, struct diff_hpp_fmt, fmt);
 483         void *ptr = dfmt - dfmt->idx;
 484         struct data__file *d = container_of(ptr, struct data__file, fmt);
 485
 486         return d;
 487 }
 488
 489 static struct hist_entry*
 490 get_pair_data(struct hist_entry *he, struct data__file *d)
 491 {
 492         if (hist_entry__has_pairs(he)) {
 493                 struct hist_entry *pair;
 494
 495                 list_for_each_entry(pair, &he->pairs.head, pairs.node)
 496                         if (pair->hists == d->hists)
 497                                 return pair;
 498         }
 499
 500         return NULL;
 501 }
 502
 503 static struct hist_entry*
 504 get_pair_fmt(struct hist_entry *he, struct diff_hpp_fmt *dfmt)
 505 {
 506         struct data__file *d = fmt_to_data_file(&dfmt->fmt);
 507
 508         return get_pair_data(he, d);
 509 }
 510
 511 static void hists__baseline_only(struct hists *hists)
 512 {
 513         struct rb_root_cached *root;
 514         struct rb_node *next;
 515
 516         if (hists__has(hists, need_collapse))
 517                 root = &hists->entries_collapsed;
 518         else
 519                 root = hists->entries_in;
 520
 521         next = rb_first_cached(root);
 522         while (next != NULL) {
 523                 struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node_in);
 524
 525                 next = rb_next(&he->rb_node_in);
 526                 if (!hist_entry__next_pair(he)) {
 527                         rb_erase_cached(&he->rb_node_in, root);
 528                         hist_entry__delete(he);
 529                 }
 530         }
 531 }
 532
 533 static int64_t block_cmp(struct perf_hpp_fmt *fmt __maybe_unused,
 534                          struct hist_entry *left, struct hist_entry *right)
 535 {
 536         struct block_info *bi_l = left->block_info;
 537         struct block_info *bi_r = right->block_info;
 538         int cmp;
 539
 540         if (!bi_l->sym || !bi_r->sym) {
 541                 if (!bi_l->sym && !bi_r->sym)
 542                         return 0;
 543                 else if (!bi_l->sym)
 544                         return -1;
 545                 else
 546                         return 1;
 547         }
 548
 549         if (bi_l->sym == bi_r->sym) {
 550                 if (bi_l->start == bi_r->start) {
 551                         if (bi_l->end == bi_r->end)
 552                                 return 0;
 553                         else
 554                                 return (int64_t)(bi_r->end - bi_l->end);
 555                 } else
 556                         return (int64_t)(bi_r->start - bi_l->start);
 557         } else {
 558                 cmp = strcmp(bi_l->sym->name, bi_r->sym->name);
 559                 return cmp;
 560         }
 561
 562         if (bi_l->sym->start != bi_r->sym->start)
 563                 return (int64_t)(bi_r->sym->start - bi_l->sym->start);
 564
 565         return (int64_t)(bi_r->sym->end - bi_l->sym->end);
 566 }
 567
 568 static int64_t block_cycles_diff_cmp(struct hist_entry *left,
 569                                      struct hist_entry *right)
 570 {
 571         bool pairs_left  = hist_entry__has_pairs(left);
 572         bool pairs_right = hist_entry__has_pairs(right);
 573         s64 l, r;
 574
 575         if (!pairs_left && !pairs_right)
 576                 return 0;
 577
 578         l = labs(left->diff.cycles);
 579         r = labs(right->diff.cycles);
 580         return r - l;
 581 }
 582
 583 static int64_t block_sort(struct perf_hpp_fmt *fmt __maybe_unused,
 584                           struct hist_entry *left, struct hist_entry *right)
 585 {
 586         return block_cycles_diff_cmp(right, left);
 587 }
 588
 589 static void init_block_hist(struct block_hist *bh)
 590 {
 591         __hists__init(&bh->block_hists, &bh->block_list);
 592         perf_hpp_list__init(&bh->block_list);
 593
 594         INIT_LIST_HEAD(&bh->block_fmt.list);
 595         INIT_LIST_HEAD(&bh->block_fmt.sort_list);
 596         bh->block_fmt.cmp = block_cmp;
 597         bh->block_fmt.sort = block_sort;
 598         perf_hpp_list__register_sort_field(&bh->block_list,
 599                                            &bh->block_fmt);
 600         bh->valid = true;
 601 }
 602
 603 static void init_block_info(struct block_info *bi, struct symbol *sym,
 604                             struct cyc_hist *ch, int offset)
 605 {
 606         bi->sym = sym;
 607         bi->start = ch->start;
 608         bi->end = offset;
 609         bi->cycles = ch->cycles;
 610         bi->cycles_aggr = ch->cycles_aggr;
 611         bi->num = ch->num;
 612         bi->num_aggr = ch->num_aggr;
 613 }
 614
 615 static int process_block_per_sym(struct hist_entry *he)
 616 {
 617         struct annotation *notes;
 618         struct cyc_hist *ch;
 619         struct block_hist *bh;
 620
 621         if (!he->ms.map || !he->ms.sym)
 622                 return 0;
 623
 624         notes = symbol__annotation(he->ms.sym);
 625         if (!notes || !notes->src || !notes->src->cycles_hist)
 626                 return 0;
 627
 628         bh = container_of(he, struct block_hist, he);
 629         init_block_hist(bh);
 630
 631         ch = notes->src->cycles_hist;
 632         for (unsigned int i = 0; i < symbol__size(he->ms.sym); i++) {
 633                 if (ch[i].num_aggr) {
 634                         struct block_info *bi;
 635                         struct hist_entry *he_block;
 636
 637                         bi = block_info__new();
 638                         if (!bi)
 639                                 return -1;
 640
 641                         init_block_info(bi, he->ms.sym, &ch[i], i);
 642                         he_block = hists__add_entry_block(&bh->block_hists,
 643                                                           &dummy_al, bi);
 644                         if (!he_block) {
 645                                 block_info__put(bi);
 646                                 return -1;
 647                         }
 648                 }
 649         }
 650
 651         return 0;
 652 }
 653
 654 static int block_pair_cmp(struct hist_entry *a, struct hist_entry *b)
 655 {
 656         struct block_info *bi_a = a->block_info;
 657         struct block_info *bi_b = b->block_info;
 658         int cmp;
 659
 660         if (!bi_a->sym || !bi_b->sym)
 661                 return -1;
 662
 663         cmp = strcmp(bi_a->sym->name, bi_b->sym->name);
 664
 665         if ((!cmp) && (bi_a->start == bi_b->start) && (bi_a->end == bi_b->end))
 666                 return 0;
 667
 668         return -1;
 669 }
 670
 671 static struct hist_entry *get_block_pair(struct hist_entry *he,
 672                                          struct hists *hists_pair)
 673 {
 674         struct rb_root_cached *root = hists_pair->entries_in;
 675         struct rb_node *next = rb_first_cached(root);
 676         int cmp;
 677
 678         while (next != NULL) {
 679                 struct hist_entry *he_pair = rb_entry(next, struct hist_entry,
 680                                                       rb_node_in);
 681
 682                 next = rb_next(&he_pair->rb_node_in);
 683
 684                 cmp = block_pair_cmp(he_pair, he);
 685                 if (!cmp)
 686                         return he_pair;
 687         }
 688
 689         return NULL;
 690 }
 691
 692 static void compute_cycles_diff(struct hist_entry *he,
 693                                 struct hist_entry *pair)
 694 {
 695         pair->diff.computed = true;
 696         if (pair->block_info->num && he->block_info->num) {
 697                 pair->diff.cycles =
 698                         pair->block_info->cycles_aggr / pair->block_info->num_aggr -
 699                         he->block_info->cycles_aggr / he->block_info->num_aggr;
 700         }
 701 }
 702
 703 static void block_hists_match(struct hists *hists_base,
 704                               struct hists *hists_pair)
 705 {
 706         struct rb_root_cached *root = hists_base->entries_in;
 707         struct rb_node *next = rb_first_cached(root);
 708
 709         while (next != NULL) {
 710                 struct hist_entry *he = rb_entry(next, struct hist_entry,
 711                                                  rb_node_in);
 712                 struct hist_entry *pair = get_block_pair(he, hists_pair);
 713
 714                 next = rb_next(&he->rb_node_in);
 715
 716                 if (pair) {
 717                         hist_entry__add_pair(pair, he);
 718                         compute_cycles_diff(he, pair);
 719                 }
 720         }
 721 }
 722
 723 static int filter_cb(struct hist_entry *he, void *arg __maybe_unused)
 724 {
 725         /* Skip the calculation of column length in output_resort */
 726         he->filtered = true;
 727         return 0;
 728 }
 729
 730 static void hists__precompute(struct hists *hists)
 731 {
 732         struct rb_root_cached *root;
 733         struct rb_node *next;
 734
 735         if (hists__has(hists, need_collapse))
 736                 root = &hists->entries_collapsed;
 737         else
 738                 root = hists->entries_in;
 739
 740         next = rb_first_cached(root);
 741         while (next != NULL) {
 742                 struct block_hist *bh, *pair_bh;
 743                 struct hist_entry *he, *pair;
 744                 struct data__file *d;
 745                 int i;
 746
 747                 he   = rb_entry(next, struct hist_entry, rb_node_in);
 748                 next = rb_next(&he->rb_node_in);
 749
 750                 if (compute == COMPUTE_CYCLES)
 751                         process_block_per_sym(he);
 752
 753                 data__for_each_file_new(i, d) {
 754                         pair = get_pair_data(he, d);
 755                         if (!pair)
 756                                 continue;
 757
 758                         switch (compute) {
 759                         case COMPUTE_DELTA:
 760                         case COMPUTE_DELTA_ABS:
 761                                 compute_delta(he, pair);
 762                                 break;
 763                         case COMPUTE_RATIO:
 764                                 compute_ratio(he, pair);
 765                                 break;
 766                         case COMPUTE_WEIGHTED_DIFF:
 767                                 compute_wdiff(he, pair);
 768                                 break;
 769                         case COMPUTE_CYCLES:
 770                                 process_block_per_sym(pair);
 771                                 bh = container_of(he, struct block_hist, he);
 772                                 pair_bh = container_of(pair, struct block_hist,
 773                                                        he);
 774
 775                                 if (bh->valid && pair_bh->valid) {
 776                                         block_hists_match(&bh->block_hists,
 777                                                           &pair_bh->block_hists);
 778                                         hists__output_resort_cb(&pair_bh->block_hists,
 779                                                                 NULL, filter_cb);
 780                                 }
 781                                 break;
 782                         default:
 783                                 BUG_ON(1);
 784                         }
 785                 }
 786         }
 787 }
 788
 789 static int64_t cmp_doubles(double l, double r)
 790 {
 791         if (l > r)
 792                 return -1;
 793         else if (l < r)
 794                 return 1;
 795         else
 796                 return 0;
 797 }
 798
 799 static int64_t
 800 __hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
 801                         int c)
 802 {
 803         switch (c) {
 804         case COMPUTE_DELTA:
 805         {
 806                 double l = left->diff.period_ratio_delta;
 807                 double r = right->diff.period_ratio_delta;
 808
 809                 return cmp_doubles(l, r);
 810         }
 811         case COMPUTE_DELTA_ABS:
 812         {
 813                 double l = fabs(left->diff.period_ratio_delta);
 814                 double r = fabs(right->diff.period_ratio_delta);
 815
 816                 return cmp_doubles(l, r);
 817         }
 818         case COMPUTE_RATIO:
 819         {
 820                 double l = left->diff.period_ratio;
 821                 double r = right->diff.period_ratio;
 822
 823                 return cmp_doubles(l, r);
 824         }
 825         case COMPUTE_WEIGHTED_DIFF:
 826         {
 827                 s64 l = left->diff.wdiff;
 828                 s64 r = right->diff.wdiff;
 829
 830                 return r - l;
 831         }
 832         default:
 833                 BUG_ON(1);
 834         }
 835
 836         return 0;
 837 }
 838
 839 static int64_t
 840 hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
 841                         int c, int sort_idx)
 842 {
 843         bool pairs_left  = hist_entry__has_pairs(left);
 844         bool pairs_right = hist_entry__has_pairs(right);
 845         struct hist_entry *p_right, *p_left;
 846
 847         if (!pairs_left && !pairs_right)
 848                 return 0;
 849
 850         if (!pairs_left || !pairs_right)
 851                 return pairs_left ? -1 : 1;
 852
 853         p_left  = get_pair_data(left,  &data__files[sort_idx]);
 854         p_right = get_pair_data(right, &data__files[sort_idx]);
 855
 856         if (!p_left && !p_right)
 857                 return 0;
 858
 859         if (!p_left || !p_right)
 860                 return p_left ? -1 : 1;
 861
 862         /*
 863          * We have 2 entries of same kind, let's
 864          * make the data comparison.
 865          */
 866         return __hist_entry__cmp_compute(p_left, p_right, c);
 867 }
 868
 869 static int64_t
 870 hist_entry__cmp_compute_idx(struct hist_entry *left, struct hist_entry *right,
 871                             int c, int sort_idx)
 872 {
 873         struct hist_entry *p_right, *p_left;
 874
 875         p_left  = get_pair_data(left,  &data__files[sort_idx]);
 876         p_right = get_pair_data(right, &data__files[sort_idx]);
 877
 878         if (!p_left && !p_right)
 879                 return 0;
 880
 881         if (!p_left || !p_right)
 882                 return p_left ? -1 : 1;
 883
 884         if (c != COMPUTE_DELTA && c != COMPUTE_DELTA_ABS) {
 885                 /*
 886                  * The delta can be computed without the baseline, but
 887                  * others are not.  Put those entries which have no
 888                  * values below.
 889                  */
 890                 if (left->dummy && right->dummy)
 891                         return 0;
 892
 893                 if (left->dummy || right->dummy)
 894                         return left->dummy ? 1 : -1;
 895         }
 896
 897         return __hist_entry__cmp_compute(p_left, p_right, c);
 898 }
 899
 900 static int64_t
 901 hist_entry__cmp_nop(struct perf_hpp_fmt *fmt __maybe_unused,
 902                     struct hist_entry *left __maybe_unused,
 903                     struct hist_entry *right __maybe_unused)
 904 {
 905         return 0;
 906 }
 907
 908 static int64_t
 909 hist_entry__cmp_baseline(struct perf_hpp_fmt *fmt __maybe_unused,
 910                          struct hist_entry *left, struct hist_entry *right)
 911 {
 912         if (left->stat.period == right->stat.period)
 913                 return 0;
 914         return left->stat.period > right->stat.period ? 1 : -1;
 915 }
 916
 917 static int64_t
 918 hist_entry__cmp_delta(struct perf_hpp_fmt *fmt,
 919                       struct hist_entry *left, struct hist_entry *right)
 920 {
 921         struct data__file *d = fmt_to_data_file(fmt);
 922
 923         return hist_entry__cmp_compute(right, left, COMPUTE_DELTA, d->idx);
 924 }
 925
 926 static int64_t
 927 hist_entry__cmp_delta_abs(struct perf_hpp_fmt *fmt,
 928                       struct hist_entry *left, struct hist_entry *right)
 929 {
 930         struct data__file *d = fmt_to_data_file(fmt);
 931
 932         return hist_entry__cmp_compute(right, left, COMPUTE_DELTA_ABS, d->idx);
 933 }
 934
 935 static int64_t
 936 hist_entry__cmp_ratio(struct perf_hpp_fmt *fmt,
 937                       struct hist_entry *left, struct hist_entry *right)
 938 {
 939         struct data__file *d = fmt_to_data_file(fmt);
 940
 941         return hist_entry__cmp_compute(right, left, COMPUTE_RATIO, d->idx);
 942 }
 943
 944 static int64_t
 945 hist_entry__cmp_wdiff(struct perf_hpp_fmt *fmt,
 946                       struct hist_entry *left, struct hist_entry *right)
 947 {
 948         struct data__file *d = fmt_to_data_file(fmt);
 949
 950         return hist_entry__cmp_compute(right, left, COMPUTE_WEIGHTED_DIFF, d->idx);
 951 }
 952
 953 static int64_t
 954 hist_entry__cmp_delta_idx(struct perf_hpp_fmt *fmt __maybe_unused,
 955                           struct hist_entry *left, struct hist_entry *right)
 956 {
 957         return hist_entry__cmp_compute_idx(right, left, COMPUTE_DELTA,
 958                                            sort_compute);
 959 }
 960
 961 static int64_t
 962 hist_entry__cmp_delta_abs_idx(struct perf_hpp_fmt *fmt __maybe_unused,
 963                               struct hist_entry *left, struct hist_entry *right)
 964 {
 965         return hist_entry__cmp_compute_idx(right, left, COMPUTE_DELTA_ABS,
 966                                            sort_compute);
 967 }
 968
 969 static int64_t
 970 hist_entry__cmp_ratio_idx(struct perf_hpp_fmt *fmt __maybe_unused,
 971                           struct hist_entry *left, struct hist_entry *right)
 972 {
 973         return hist_entry__cmp_compute_idx(right, left, COMPUTE_RATIO,
 974                                            sort_compute);
 975 }
 976
 977 static int64_t
 978 hist_entry__cmp_wdiff_idx(struct perf_hpp_fmt *fmt __maybe_unused,
 979                           struct hist_entry *left, struct hist_entry *right)
 980 {
 981         return hist_entry__cmp_compute_idx(right, left, COMPUTE_WEIGHTED_DIFF,
 982                                            sort_compute);
 983 }
 984
 985 static void hists__process(struct hists *hists)
 986 {
 987         if (show_baseline_only)
 988                 hists__baseline_only(hists);
 989
 990         hists__precompute(hists);
 991         hists__output_resort(hists, NULL);
 992
 993         if (compute == COMPUTE_CYCLES)
 994                 symbol_conf.report_block = true;
 995
 996         hists__fprintf(hists, !quiet, 0, 0, 0, stdout,
 997                        !symbol_conf.use_callchain);
 998 }
 999
1000 static void data__fprintf(void)
1001 {
1002         struct data__file *d;
1003         int i;
1004
1005         fprintf(stdout, "# Data files:\n");
1006
1007         data__for_each_file(i, d)
1008                 fprintf(stdout, "#  [%d] %s %s\n",
1009                         d->idx, d->data.path,
1010                         !d->idx ? "(Baseline)" : "");
1011
1012         fprintf(stdout, "#\n");
1013 }
1014
1015 static void data_process(void)
1016 {
1017         struct evlist *evlist_base = data__files[0].session->evlist;
1018         struct evsel *evsel_base;
1019         bool first = true;
1020
1021         evlist__for_each_entry(evlist_base, evsel_base) {
1022                 struct hists *hists_base = evsel__hists(evsel_base);
1023                 struct data__file *d;
1024                 int i;
1025
1026                 data__for_each_file_new(i, d) {
1027                         struct evlist *evlist = d->session->evlist;
1028                         struct evsel *evsel;
1029                         struct hists *hists;
1030
1031                         evsel = evsel_match(evsel_base, evlist);
1032                         if (!evsel)
1033                                 continue;
1034
1035                         hists = evsel__hists(evsel);
1036                         d->hists = hists;
1037
1038                         hists__match(hists_base, hists);
1039
1040                         if (!show_baseline_only)
1041                                 hists__link(hists_base, hists);
1042                 }
1043
1044                 if (!quiet) {
1045                         fprintf(stdout, "%s# Event '%s'\n#\n", first ? "" : "\n",
1046                                 perf_evsel__name(evsel_base));
1047                 }
1048
1049                 first = false;
1050
1051                 if (verbose > 0 || ((data__files_cnt > 2) && !quiet))
1052                         data__fprintf();
1053
1054                 /* Don't sort callchain for perf diff */
1055                 perf_evsel__reset_sample_bit(evsel_base, CALLCHAIN);
1056
1057                 hists__process(hists_base);
1058         }
1059 }
1060
1061 static void data__free(struct data__file *d)
1062 {
1063         int col;
1064
1065         for (col = 0; col < PERF_HPP_DIFF__MAX_INDEX; col++) {
1066                 struct diff_hpp_fmt *fmt = &d->fmt[col];
1067
1068                 zfree(&fmt->header);
1069         }
1070 }
1071
1072 static int abstime_str_dup(char **pstr)
1073 {
1074         char *str = NULL;
1075
1076         if (pdiff.time_str && strchr(pdiff.time_str, ':')) {
1077                 str = strdup(pdiff.time_str);
1078                 if (!str)
1079                         return -ENOMEM;
1080         }
1081
1082         *pstr = str;
1083         return 0;
1084 }
1085
1086 static int parse_absolute_time(struct data__file *d, char **pstr)
1087 {
1088         char *p = *pstr;
1089         int ret;
1090
1091         /*
1092          * Absolute timestamp for one file has the format: a.b,c.d
1093          * For multiple files, the format is: a.b,c.d:a.b,c.d
1094          */
1095         p = strchr(*pstr, ':');
1096         if (p) {
1097                 if (p == *pstr) {
1098                         pr_err("Invalid time string\n");
1099                         return -EINVAL;
1100                 }
1101
1102                 *p = 0;
1103                 p++;
1104                 if (*p == 0) {
1105                         pr_err("Invalid time string\n");
1106                         return -EINVAL;
1107                 }
1108         }
1109
1110         ret = perf_time__parse_for_ranges(*pstr, d->session,
1111                                           &pdiff.ptime_range,
1112                                           &pdiff.range_size,
1113                                           &pdiff.range_num);
1114         if (ret < 0)
1115                 return ret;
1116
1117         if (!p || *p == 0)
1118                 *pstr = NULL;
1119         else
1120                 *pstr = p;
1121
1122         return ret;
1123 }
1124
1125 static int parse_percent_time(struct data__file *d)
1126 {
1127         int ret;
1128
1129         ret = perf_time__parse_for_ranges(pdiff.time_str, d->session,
1130                                           &pdiff.ptime_range,
1131                                           &pdiff.range_size,
1132                                           &pdiff.range_num);
1133         return ret;
1134 }
1135
1136 static int parse_time_str(struct data__file *d, char *abstime_ostr,
1137                            char **pabstime_tmp)
1138 {
1139         int ret = 0;
1140
1141         if (abstime_ostr)
1142                 ret = parse_absolute_time(d, pabstime_tmp);
1143         else if (pdiff.time_str)
1144                 ret = parse_percent_time(d);
1145
1146         return ret;
1147 }
1148
1149 static int check_file_brstack(void)
1150 {
1151         struct data__file *d;
1152         bool has_br_stack;
1153         int i;
1154
1155         data__for_each_file(i, d) {
1156                 d->session = perf_session__new(&d->data, false, &pdiff.tool);
1157                 if (IS_ERR(d->session)) {
1158                         pr_err("Failed to open %s\n", d->data.path);
1159                         return PTR_ERR(d->session);
1160                 }
1161
1162                 has_br_stack = perf_header__has_feat(&d->session->header,
1163                                                      HEADER_BRANCH_STACK);
1164                 perf_session__delete(d->session);
1165                 if (!has_br_stack)
1166                         return 0;
1167         }
1168
1169         /* Set only all files having branch stacks */
1170         pdiff.has_br_stack = true;
1171         return 0;
1172 }
1173
1174 static int __cmd_diff(void)
1175 {
1176         struct data__file *d;
1177         int ret, i;
1178         char *abstime_ostr, *abstime_tmp;
1179
1180         ret = abstime_str_dup(&abstime_ostr);
1181         if (ret)
1182                 return ret;
1183
1184         abstime_tmp = abstime_ostr;
1185         ret = -EINVAL;
1186
1187         data__for_each_file(i, d) {
1188                 d->session = perf_session__new(&d->data, false, &pdiff.tool);
1189                 if (IS_ERR(d->session)) {
1190                         ret = PTR_ERR(d->session);
1191                         pr_err("Failed to open %s\n", d->data.path);
1192                         goto out_delete;
1193                 }
1194
1195                 if (pdiff.time_str) {
1196                         ret = parse_time_str(d, abstime_ostr, &abstime_tmp);
1197                         if (ret < 0)
1198                                 goto out_delete;
1199                 }
1200
1201                 if (cpu_list) {
1202                         ret = perf_session__cpu_bitmap(d->session, cpu_list,
1203                                                        cpu_bitmap);
1204                         if (ret < 0)
1205                                 goto out_delete;
1206                 }
1207
1208                 ret = perf_session__process_events(d->session);
1209                 if (ret) {
1210                         pr_err("Failed to process %s\n", d->data.path);
1211                         goto out_delete;
1212                 }
1213
1214                 perf_evlist__collapse_resort(d->session->evlist);
1215
1216                 if (pdiff.ptime_range)
1217                         zfree(&pdiff.ptime_range);
1218         }
1219
1220         data_process();
1221
1222  out_delete:
1223         data__for_each_file(i, d) {
1224                 perf_session__delete(d->session);
1225                 data__free(d);
1226         }
1227
1228         free(data__files);
1229
1230         if (pdiff.ptime_range)
1231                 zfree(&pdiff.ptime_range);
1232
1233         if (abstime_ostr)
1234                 free(abstime_ostr);
1235
1236         return ret;
1237 }
1238
1239 static const char * const diff_usage[] = {
1240         "perf diff [<options>] [old_file] [new_file]",
1241         NULL,
1242 };
1243
1244 static const struct option options[] = {
1245         OPT_INCR('v', "verbose", &verbose,
1246                     "be more verbose (show symbol address, etc)"),
1247         OPT_BOOLEAN('q', "quiet", &quiet, "Do not show any message"),
1248         OPT_BOOLEAN('b', "baseline-only", &show_baseline_only,
1249                     "Show only items with match in baseline"),
1250         OPT_CALLBACK('c', "compute", &compute,
1251                      "delta,delta-abs,ratio,wdiff:w1,w2 (default delta-abs),cycles",
1252                      "Entries differential computation selection",
1253                      setup_compute),
1254         OPT_BOOLEAN('p', "period", &show_period,
1255                     "Show period values."),
1256         OPT_BOOLEAN('F', "formula", &show_formula,
1257                     "Show formula."),
1258         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1259                     "dump raw trace in ASCII"),
1260         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
1261         OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
1262                    "file", "kallsyms pathname"),
1263         OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
1264                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
1265         OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
1266                    "only consider symbols in these dsos"),
1267         OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
1268                    "only consider symbols in these comms"),
1269         OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
1270                    "only consider these symbols"),
1271         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
1272                    "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."
1273                    " Please refer the man page for the complete list."),
1274         OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",
1275                    "separator for columns, no spaces will be added between "
1276                    "columns '.' is reserved."),
1277         OPT_CALLBACK(0, "symfs", NULL, "directory",
1278                      "Look for files with symbols relative to this directory",
1279                      symbol__config_symfs),
1280         OPT_UINTEGER('o', "order", &sort_compute, "Specify compute sorting."),
1281         OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
1282                      "How to display percentage of filtered entries", parse_filter_percentage),
1283         OPT_STRING(0, "time", &pdiff.time_str, "str",
1284                    "Time span (time percent or absolute timestamp)"),
1285         OPT_STRING(0, "cpu", &cpu_list, "cpu", "list of cpus to profile"),
1286         OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
1287                    "only consider symbols in these pids"),
1288         OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
1289                    "only consider symbols in these tids"),
1290         OPT_END()
1291 };
1292
1293 static double baseline_percent(struct hist_entry *he)
1294 {
1295         u64 total = hists__total_period(he->hists);
1296
1297         return 100.0 * he->stat.period / total;
1298 }
1299
1300 static int hpp__color_baseline(struct perf_hpp_fmt *fmt,
1301                                struct perf_hpp *hpp, struct hist_entry *he)
1302 {
1303         struct diff_hpp_fmt *dfmt =
1304                 container_of(fmt, struct diff_hpp_fmt, fmt);
1305         double percent = baseline_percent(he);
1306         char pfmt[20] = " ";
1307
1308         if (!he->dummy) {
1309                 scnprintf(pfmt, 20, "%%%d.2f%%%%", dfmt->header_width - 1);
1310                 return percent_color_snprintf(hpp->buf, hpp->size,
1311                                               pfmt, percent);
1312         } else
1313                 return scnprintf(hpp->buf, hpp->size, "%*s",
1314                                  dfmt->header_width, pfmt);
1315 }
1316
1317 static int hpp__entry_baseline(struct hist_entry *he, char *buf, size_t size)
1318 {
1319         double percent = baseline_percent(he);
1320         const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%";
1321         int ret = 0;
1322
1323         if (!he->dummy)
1324                 ret = scnprintf(buf, size, fmt, percent);
1325
1326         return ret;
1327 }
1328
1329 static int cycles_printf(struct hist_entry *he, struct hist_entry *pair,
1330                          struct perf_hpp *hpp, int width)
1331 {
1332         struct block_hist *bh = container_of(he, struct block_hist, he);
1333         struct block_hist *bh_pair = container_of(pair, struct block_hist, he);
1334         struct hist_entry *block_he;
1335         struct block_info *bi;
1336         char buf[128];
1337         char *start_line, *end_line;
1338
1339         block_he = hists__get_entry(&bh_pair->block_hists, bh->block_idx);
1340         if (!block_he) {
1341                 hpp->skip = true;
1342                 return 0;
1343         }
1344
1345         /*
1346          * Avoid printing the warning "addr2line_init failed for ..."
1347          */
1348         symbol_conf.disable_add2line_warn = true;
1349
1350         bi = block_he->block_info;
1351
1352         start_line = map__srcline(he->ms.map, bi->sym->start + bi->start,
1353                                   he->ms.sym);
1354
1355         end_line = map__srcline(he->ms.map, bi->sym->start + bi->end,
1356                                 he->ms.sym);
1357
1358         if ((start_line != SRCLINE_UNKNOWN) && (end_line != SRCLINE_UNKNOWN)) {
1359                 scnprintf(buf, sizeof(buf), "[%s -> %s] %4ld",
1360                           start_line, end_line, block_he->diff.cycles);
1361         } else {
1362                 scnprintf(buf, sizeof(buf), "[%7lx -> %7lx] %4ld",
1363                           bi->start, bi->end, block_he->diff.cycles);
1364         }
1365
1366         free_srcline(start_line);
1367         free_srcline(end_line);
1368
1369         return scnprintf(hpp->buf, hpp->size, "%*s", width, buf);
1370 }
1371
1372 static int __hpp__color_compare(struct perf_hpp_fmt *fmt,
1373                                 struct perf_hpp *hpp, struct hist_entry *he,
1374                                 int comparison_method)
1375 {
1376         struct diff_hpp_fmt *dfmt =
1377                 container_of(fmt, struct diff_hpp_fmt, fmt);
1378         struct hist_entry *pair = get_pair_fmt(he, dfmt);
1379         double diff;
1380         s64 wdiff;
1381         char pfmt[20] = " ";
1382
1383         if (!pair) {
1384                 if (comparison_method == COMPUTE_CYCLES) {
1385                         struct block_hist *bh;
1386
1387                         bh = container_of(he, struct block_hist, he);
1388                         if (bh->block_idx)
1389                                 hpp->skip = true;
1390                 }
1391
1392                 goto no_print;
1393         }
1394
1395         switch (comparison_method) {
1396         case COMPUTE_DELTA:
1397                 if (pair->diff.computed)
1398                         diff = pair->diff.period_ratio_delta;
1399                 else
1400                         diff = compute_delta(he, pair);
1401
1402                 scnprintf(pfmt, 20, "%%%+d.2f%%%%", dfmt->header_width - 1);
1403                 return percent_color_snprintf(hpp->buf, hpp->size,
1404                                         pfmt, diff);
1405         case COMPUTE_RATIO:
1406                 if (he->dummy)
1407                         goto dummy_print;
1408                 if (pair->diff.computed)
1409                         diff = pair->diff.period_ratio;
1410                 else
1411                         diff = compute_ratio(he, pair);
1412
1413                 scnprintf(pfmt, 20, "%%%d.6f", dfmt->header_width);
1414                 return value_color_snprintf(hpp->buf, hpp->size,
1415                                         pfmt, diff);
1416         case COMPUTE_WEIGHTED_DIFF:
1417                 if (he->dummy)
1418                         goto dummy_print;
1419                 if (pair->diff.computed)
1420                         wdiff = pair->diff.wdiff;
1421                 else
1422                         wdiff = compute_wdiff(he, pair);
1423
1424                 scnprintf(pfmt, 20, "%%14ld", dfmt->header_width);
1425                 return color_snprintf(hpp->buf, hpp->size,
1426                                 get_percent_color(wdiff),
1427                                 pfmt, wdiff);
1428         case COMPUTE_CYCLES:
1429                 return cycles_printf(he, pair, hpp, dfmt->header_width);
1430         default:
1431                 BUG_ON(1);
1432         }
1433 dummy_print:
1434         return scnprintf(hpp->buf, hpp->size, "%*s",
1435                         dfmt->header_width, "N/A");
1436 no_print:
1437         return scnprintf(hpp->buf, hpp->size, "%*s",
1438                         dfmt->header_width, pfmt);
1439 }
1440
1441 static int hpp__color_delta(struct perf_hpp_fmt *fmt,
1442                         struct perf_hpp *hpp, struct hist_entry *he)
1443 {
1444         return __hpp__color_compare(fmt, hpp, he, COMPUTE_DELTA);
1445 }
1446
1447 static int hpp__color_ratio(struct perf_hpp_fmt *fmt,
1448                         struct perf_hpp *hpp, struct hist_entry *he)
1449 {
1450         return __hpp__color_compare(fmt, hpp, he, COMPUTE_RATIO);
1451 }
1452
1453 static int hpp__color_wdiff(struct perf_hpp_fmt *fmt,
1454                         struct perf_hpp *hpp, struct hist_entry *he)
1455 {
1456         return __hpp__color_compare(fmt, hpp, he, COMPUTE_WEIGHTED_DIFF);
1457 }
1458
1459 static int hpp__color_cycles(struct perf_hpp_fmt *fmt,
1460                              struct perf_hpp *hpp, struct hist_entry *he)
1461 {
1462         return __hpp__color_compare(fmt, hpp, he, COMPUTE_CYCLES);
1463 }
1464
1465 static void
1466 hpp__entry_unpair(struct hist_entry *he, int idx, char *buf, size_t size)
1467 {
1468         switch (idx) {
1469         case PERF_HPP_DIFF__PERIOD_BASELINE:
1470                 scnprintf(buf, size, "%" PRIu64, he->stat.period);
1471                 break;
1472
1473         default:
1474                 break;
1475         }
1476 }
1477
1478 static void
1479 hpp__entry_pair(struct hist_entry *he, struct hist_entry *pair,
1480                 int idx, char *buf, size_t size)
1481 {
1482         double diff;
1483         double ratio;
1484         s64 wdiff;
1485
1486         switch (idx) {
1487         case PERF_HPP_DIFF__DELTA:
1488         case PERF_HPP_DIFF__DELTA_ABS:
1489                 if (pair->diff.computed)
1490                         diff = pair->diff.period_ratio_delta;
1491                 else
1492                         diff = compute_delta(he, pair);
1493
1494                 scnprintf(buf, size, "%+4.2F%%", diff);
1495                 break;
1496
1497         case PERF_HPP_DIFF__RATIO:
1498                 /* No point for ratio number if we are dummy.. */
1499                 if (he->dummy) {
1500                         scnprintf(buf, size, "N/A");
1501                         break;
1502                 }
1503
1504                 if (pair->diff.computed)
1505                         ratio = pair->diff.period_ratio;
1506                 else
1507                         ratio = compute_ratio(he, pair);
1508
1509                 if (ratio > 0.0)
1510                         scnprintf(buf, size, "%14.6F", ratio);
1511                 break;
1512
1513         case PERF_HPP_DIFF__WEIGHTED_DIFF:
1514                 /* No point for wdiff number if we are dummy.. */
1515                 if (he->dummy) {
1516                         scnprintf(buf, size, "N/A");
1517                         break;
1518                 }
1519
1520                 if (pair->diff.computed)
1521                         wdiff = pair->diff.wdiff;
1522                 else
1523                         wdiff = compute_wdiff(he, pair);
1524
1525                 if (wdiff != 0)
1526                         scnprintf(buf, size, "%14ld", wdiff);
1527                 break;
1528
1529         case PERF_HPP_DIFF__FORMULA:
1530                 formula_fprintf(he, pair, buf, size);
1531                 break;
1532
1533         case PERF_HPP_DIFF__PERIOD:
1534                 scnprintf(buf, size, "%" PRIu64, pair->stat.period);
1535                 break;
1536
1537         default:
1538                 BUG_ON(1);
1539         };
1540 }
1541
1542 static void
1543 __hpp__entry_global(struct hist_entry *he, struct diff_hpp_fmt *dfmt,
1544                     char *buf, size_t size)
1545 {
1546         struct hist_entry *pair = get_pair_fmt(he, dfmt);
1547         int idx = dfmt->idx;
1548
1549         /* baseline is special */
1550         if (idx == PERF_HPP_DIFF__BASELINE)
1551                 hpp__entry_baseline(he, buf, size);
1552         else {
1553                 if (pair)
1554                         hpp__entry_pair(he, pair, idx, buf, size);
1555                 else
1556                         hpp__entry_unpair(he, idx, buf, size);
1557         }
1558 }
1559
1560 static int hpp__entry_global(struct perf_hpp_fmt *_fmt, struct perf_hpp *hpp,
1561                              struct hist_entry *he)
1562 {
1563         struct diff_hpp_fmt *dfmt =
1564                 container_of(_fmt, struct diff_hpp_fmt, fmt);
1565         char buf[MAX_COL_WIDTH] = " ";
1566
1567         __hpp__entry_global(he, dfmt, buf, MAX_COL_WIDTH);
1568
1569         if (symbol_conf.field_sep)
1570                 return scnprintf(hpp->buf, hpp->size, "%s", buf);
1571         else
1572                 return scnprintf(hpp->buf, hpp->size, "%*s",
1573                                  dfmt->header_width, buf);
1574 }
1575
1576 static int hpp__header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1577                        struct hists *hists __maybe_unused,
1578                        int line __maybe_unused,
1579                        int *span __maybe_unused)
1580 {
1581         struct diff_hpp_fmt *dfmt =
1582                 container_of(fmt, struct diff_hpp_fmt, fmt);
1583
1584         BUG_ON(!dfmt->header);
1585         return scnprintf(hpp->buf, hpp->size, dfmt->header);
1586 }
1587
1588 static int hpp__width(struct perf_hpp_fmt *fmt,
1589                       struct perf_hpp *hpp __maybe_unused,
1590                       struct hists *hists __maybe_unused)
1591 {
1592         struct diff_hpp_fmt *dfmt =
1593                 container_of(fmt, struct diff_hpp_fmt, fmt);
1594
1595         BUG_ON(dfmt->header_width <= 0);
1596         return dfmt->header_width;
1597 }
1598
1599 static void init_header(struct data__file *d, struct diff_hpp_fmt *dfmt)
1600 {
1601 #define MAX_HEADER_NAME 100
1602         char buf_indent[MAX_HEADER_NAME];
1603         char buf[MAX_HEADER_NAME];
1604         const char *header = NULL;
1605         int width = 0;
1606
1607         BUG_ON(dfmt->idx >= PERF_HPP_DIFF__MAX_INDEX);
1608         header = columns[dfmt->idx].name;
1609         width  = columns[dfmt->idx].width;
1610
1611         /* Only our defined HPP fmts should appear here. */
1612         BUG_ON(!header);
1613
1614         if (data__files_cnt > 2)
1615                 scnprintf(buf, MAX_HEADER_NAME, "%s/%d", header, d->idx);
1616
1617 #define NAME (data__files_cnt > 2 ? buf : header)
1618         dfmt->header_width = width;
1619         width = (int) strlen(NAME);
1620         if (dfmt->header_width < width)
1621                 dfmt->header_width = width;
1622
1623         scnprintf(buf_indent, MAX_HEADER_NAME, "%*s",
1624                   dfmt->header_width, NAME);
1625
1626         dfmt->header = strdup(buf_indent);
1627 #undef MAX_HEADER_NAME
1628 #undef NAME
1629 }
1630
1631 static void data__hpp_register(struct data__file *d, int idx)
1632 {
1633         struct diff_hpp_fmt *dfmt = &d->fmt[idx];
1634         struct perf_hpp_fmt *fmt = &dfmt->fmt;
1635
1636         dfmt->idx = idx;
1637
1638         fmt->header = hpp__header;
1639         fmt->width  = hpp__width;
1640         fmt->entry  = hpp__entry_global;
1641         fmt->cmp    = hist_entry__cmp_nop;
1642         fmt->collapse = hist_entry__cmp_nop;
1643
1644         /* TODO more colors */
1645         switch (idx) {
1646         case PERF_HPP_DIFF__BASELINE:
1647                 fmt->color = hpp__color_baseline;
1648                 fmt->sort  = hist_entry__cmp_baseline;
1649                 break;
1650         case PERF_HPP_DIFF__DELTA:
1651                 fmt->color = hpp__color_delta;
1652                 fmt->sort  = hist_entry__cmp_delta;
1653                 break;
1654         case PERF_HPP_DIFF__RATIO:
1655                 fmt->color = hpp__color_ratio;
1656                 fmt->sort  = hist_entry__cmp_ratio;
1657                 break;
1658         case PERF_HPP_DIFF__WEIGHTED_DIFF:
1659                 fmt->color = hpp__color_wdiff;
1660                 fmt->sort  = hist_entry__cmp_wdiff;
1661                 break;
1662         case PERF_HPP_DIFF__DELTA_ABS:
1663                 fmt->color = hpp__color_delta;
1664                 fmt->sort  = hist_entry__cmp_delta_abs;
1665                 break;
1666         case PERF_HPP_DIFF__CYCLES:
1667                 fmt->color = hpp__color_cycles;
1668                 fmt->sort  = hist_entry__cmp_nop;
1669                 break;
1670         default:
1671                 fmt->sort  = hist_entry__cmp_nop;
1672                 break;
1673         }
1674
1675         init_header(d, dfmt);
1676         perf_hpp__column_register(fmt);
1677         perf_hpp__register_sort_field(fmt);
1678 }
1679
1680 static int ui_init(void)
1681 {
1682         struct data__file *d;
1683         struct perf_hpp_fmt *fmt;
1684         int i;
1685
1686         data__for_each_file(i, d) {
1687
1688                 /*
1689                  * Baseline or compute realted columns:
1690                  *
1691                  *   PERF_HPP_DIFF__BASELINE
1692                  *   PERF_HPP_DIFF__DELTA
1693                  *   PERF_HPP_DIFF__RATIO
1694                  *   PERF_HPP_DIFF__WEIGHTED_DIFF
1695                  */
1696                 data__hpp_register(d, i ? compute_2_hpp[compute] :
1697                                           PERF_HPP_DIFF__BASELINE);
1698
1699                 /*
1700                  * And the rest:
1701                  *
1702                  * PERF_HPP_DIFF__FORMULA
1703                  * PERF_HPP_DIFF__PERIOD
1704                  * PERF_HPP_DIFF__PERIOD_BASELINE
1705                  */
1706                 if (show_formula && i)
1707                         data__hpp_register(d, PERF_HPP_DIFF__FORMULA);
1708
1709                 if (show_period)
1710                         data__hpp_register(d, i ? PERF_HPP_DIFF__PERIOD :
1711                                                   PERF_HPP_DIFF__PERIOD_BASELINE);
1712         }
1713
1714         if (!sort_compute)
1715                 return 0;
1716
1717         /*
1718          * Prepend an fmt to sort on columns at 'sort_compute' first.
1719          * This fmt is added only to the sort list but not to the
1720          * output fields list.
1721          *
1722          * Note that this column (data) can be compared twice - one
1723          * for this 'sort_compute' fmt and another for the normal
1724          * diff_hpp_fmt.  But it shouldn't a problem as most entries
1725          * will be sorted out by first try or baseline and comparing
1726          * is not a costly operation.
1727          */
1728         fmt = zalloc(sizeof(*fmt));
1729         if (fmt == NULL) {
1730                 pr_err("Memory allocation failed\n");
1731                 return -1;
1732         }
1733
1734         fmt->cmp      = hist_entry__cmp_nop;
1735         fmt->collapse = hist_entry__cmp_nop;
1736
1737         switch (compute) {
1738         case COMPUTE_DELTA:
1739                 fmt->sort = hist_entry__cmp_delta_idx;
1740                 break;
1741         case COMPUTE_RATIO:
1742                 fmt->sort = hist_entry__cmp_ratio_idx;
1743                 break;
1744         case COMPUTE_WEIGHTED_DIFF:
1745                 fmt->sort = hist_entry__cmp_wdiff_idx;
1746                 break;
1747         case COMPUTE_DELTA_ABS:
1748                 fmt->sort = hist_entry__cmp_delta_abs_idx;
1749                 break;
1750         case COMPUTE_CYCLES:
1751                 /*
1752                  * Should set since 'fmt->sort' is called without
1753                  * checking valid during sorting
1754                  */
1755                 fmt->sort = hist_entry__cmp_nop;
1756                 break;
1757         default:
1758                 BUG_ON(1);
1759         }
1760
1761         perf_hpp__prepend_sort_field(fmt);
1762         return 0;
1763 }
1764
1765 static int data_init(int argc, const char **argv)
1766 {
1767         struct data__file *d;
1768         static const char *defaults[] = {
1769                 "perf.data.old",
1770                 "perf.data",
1771         };
1772         bool use_default = true;
1773         int i;
1774
1775         data__files_cnt = 2;
1776
1777         if (argc) {
1778                 if (argc == 1)
1779                         defaults[1] = argv[0];
1780                 else {
1781                         data__files_cnt = argc;
1782                         use_default = false;
1783                 }
1784         } else if (perf_guest) {
1785                 defaults[0] = "perf.data.host";
1786                 defaults[1] = "perf.data.guest";
1787         }
1788
1789         if (sort_compute >= (unsigned int) data__files_cnt) {
1790                 pr_err("Order option out of limit.\n");
1791                 return -EINVAL;
1792         }
1793
1794         data__files = zalloc(sizeof(*data__files) * data__files_cnt);
1795         if (!data__files)
1796                 return -ENOMEM;
1797
1798         data__for_each_file(i, d) {
1799                 struct perf_data *data = &d->data;
1800
1801                 data->path  = use_default ? defaults[i] : argv[i];
1802                 data->mode  = PERF_DATA_MODE_READ,
1803                 data->force = force,
1804
1805                 d->idx  = i;
1806         }
1807
1808         return 0;
1809 }
1810
1811 static int diff__config(const char *var, const char *value,
1812                         void *cb __maybe_unused)
1813 {
1814         if (!strcmp(var, "diff.order")) {
1815                 int ret;
1816                 if (perf_config_int(&ret, var, value) < 0)
1817                         return -1;
1818                 sort_compute = ret;
1819                 return 0;
1820         }
1821         if (!strcmp(var, "diff.compute")) {
1822                 if (!strcmp(value, "delta")) {
1823                         compute = COMPUTE_DELTA;
1824                 } else if (!strcmp(value, "delta-abs")) {
1825                         compute = COMPUTE_DELTA_ABS;
1826                 } else if (!strcmp(value, "ratio")) {
1827                         compute = COMPUTE_RATIO;
1828                 } else if (!strcmp(value, "wdiff")) {
1829                         compute = COMPUTE_WEIGHTED_DIFF;
1830                 } else {
1831                         pr_err("Invalid compute method: %s\n", value);
1832                         return -1;
1833                 }
1834         }
1835
1836         return 0;
1837 }
1838
1839 int cmd_diff(int argc, const char **argv)
1840 {
1841         int ret = hists__init();
1842
1843         if (ret < 0)
1844                 return ret;
1845
1846         perf_config(diff__config, NULL);
1847
1848         argc = parse_options(argc, argv, options, diff_usage, 0);
1849
1850         if (quiet)
1851                 perf_quiet_option();
1852
1853         symbol__annotation_init();
1854
1855         if (symbol__init(NULL) < 0)
1856                 return -1;
1857
1858         if (data_init(argc, argv) < 0)
1859                 return -1;
1860
1861         if (check_file_brstack() < 0)
1862                 return -1;
1863
1864         if (compute == COMPUTE_CYCLES && !pdiff.has_br_stack)
1865                 return -1;
1866
1867         if (ui_init() < 0)
1868                 return -1;
1869
1870         sort__mode = SORT_MODE__DIFF;
1871
1872         if (setup_sorting(NULL) < 0)
1873                 usage_with_options(diff_usage, options);
1874
1875         setup_pager();
1876
1877         sort__setup_elide(NULL);
1878
1879         return __cmd_diff();
1880 }