tools/perf/util/hist.c

   1 #include "util.h"
   2 #include "build-id.h"
   3 #include "hist.h"
   4 #include "session.h"
   5 #include "sort.h"
   6 #include "evsel.h"
   7 #include <math.h>
   8
   9 static bool hists__filter_entry_by_dso(struct hists *hists,
  10                                        struct hist_entry *he);
  11 static bool hists__filter_entry_by_thread(struct hists *hists,
  12                                           struct hist_entry *he);
  13 static bool hists__filter_entry_by_symbol(struct hists *hists,
  14                                           struct hist_entry *he);
  15
  16 struct callchain_param  callchain_param = {
  17         .mode   = CHAIN_GRAPH_REL,
  18         .min_percent = 0.5,
  19         .order  = ORDER_CALLEE,
  20         .key    = CCKEY_FUNCTION
  21 };
  22
  23 u16 hists__col_len(struct hists *hists, enum hist_column col)
  24 {
  25         return hists->col_len[col];
  26 }
  27
  28 void hists__set_col_len(struct hists *hists, enum hist_column col, u16 len)
  29 {
  30         hists->col_len[col] = len;
  31 }
  32
  33 bool hists__new_col_len(struct hists *hists, enum hist_column col, u16 len)
  34 {
  35         if (len > hists__col_len(hists, col)) {
  36                 hists__set_col_len(hists, col, len);
  37                 return true;
  38         }
  39         return false;
  40 }
  41
  42 void hists__reset_col_len(struct hists *hists)
  43 {
  44         enum hist_column col;
  45
  46         for (col = 0; col < HISTC_NR_COLS; ++col)
  47                 hists__set_col_len(hists, col, 0);
  48 }
  49
  50 static void hists__set_unres_dso_col_len(struct hists *hists, int dso)
  51 {
  52         const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
  53
  54         if (hists__col_len(hists, dso) < unresolved_col_width &&
  55             !symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
  56             !symbol_conf.dso_list)
  57                 hists__set_col_len(hists, dso, unresolved_col_width);
  58 }
  59
  60 void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
  61 {
  62         const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
  63         int symlen;
  64         u16 len;
  65
  66         /*
  67          * +4 accounts for '[x] ' priv level info
  68          * +2 accounts for 0x prefix on raw addresses
  69          * +3 accounts for ' y ' symtab origin info
  70          */
  71         if (h->ms.sym) {
  72                 symlen = h->ms.sym->namelen + 4;
  73                 if (verbose)
  74                         symlen += BITS_PER_LONG / 4 + 2 + 3;
  75                 hists__new_col_len(hists, HISTC_SYMBOL, symlen);
  76         } else {
  77                 symlen = unresolved_col_width + 4 + 2;
  78                 hists__new_col_len(hists, HISTC_SYMBOL, symlen);
  79                 hists__set_unres_dso_col_len(hists, HISTC_DSO);
  80         }
  81
  82         len = thread__comm_len(h->thread);
  83         if (hists__new_col_len(hists, HISTC_COMM, len))
  84                 hists__set_col_len(hists, HISTC_THREAD, len + 6);
  85
  86         if (h->ms.map) {
  87                 len = dso__name_len(h->ms.map->dso);
  88                 hists__new_col_len(hists, HISTC_DSO, len);
  89         }
  90
  91         if (h->parent)
  92                 hists__new_col_len(hists, HISTC_PARENT, h->parent->namelen);
  93
  94         if (h->branch_info) {
  95                 if (h->branch_info->from.sym) {
  96                         symlen = (int)h->branch_info->from.sym->namelen + 4;
  97                         if (verbose)
  98                                 symlen += BITS_PER_LONG / 4 + 2 + 3;
  99                         hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
 100
 101                         symlen = dso__name_len(h->branch_info->from.map->dso);
 102                         hists__new_col_len(hists, HISTC_DSO_FROM, symlen);
 103                 } else {
 104                         symlen = unresolved_col_width + 4 + 2;
 105                         hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
 106                         hists__set_unres_dso_col_len(hists, HISTC_DSO_FROM);
 107                 }
 108
 109                 if (h->branch_info->to.sym) {
 110                         symlen = (int)h->branch_info->to.sym->namelen + 4;
 111                         if (verbose)
 112                                 symlen += BITS_PER_LONG / 4 + 2 + 3;
 113                         hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
 114
 115                         symlen = dso__name_len(h->branch_info->to.map->dso);
 116                         hists__new_col_len(hists, HISTC_DSO_TO, symlen);
 117                 } else {
 118                         symlen = unresolved_col_width + 4 + 2;
 119                         hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
 120                         hists__set_unres_dso_col_len(hists, HISTC_DSO_TO);
 121                 }
 122         }
 123
 124         if (h->mem_info) {
 125                 if (h->mem_info->daddr.sym) {
 126                         symlen = (int)h->mem_info->daddr.sym->namelen + 4
 127                                + unresolved_col_width + 2;
 128                         hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL,
 129                                            symlen);
 130                 } else {
 131                         symlen = unresolved_col_width + 4 + 2;
 132                         hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL,
 133                                            symlen);
 134                 }
 135                 if (h->mem_info->daddr.map) {
 136                         symlen = dso__name_len(h->mem_info->daddr.map->dso);
 137                         hists__new_col_len(hists, HISTC_MEM_DADDR_DSO,
 138                                            symlen);
 139                 } else {
 140                         symlen = unresolved_col_width + 4 + 2;
 141                         hists__set_unres_dso_col_len(hists, HISTC_MEM_DADDR_DSO);
 142                 }
 143         } else {
 144                 symlen = unresolved_col_width + 4 + 2;
 145                 hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL, symlen);
 146                 hists__set_unres_dso_col_len(hists, HISTC_MEM_DADDR_DSO);
 147         }
 148
 149         hists__new_col_len(hists, HISTC_MEM_LOCKED, 6);
 150         hists__new_col_len(hists, HISTC_MEM_TLB, 22);
 151         hists__new_col_len(hists, HISTC_MEM_SNOOP, 12);
 152         hists__new_col_len(hists, HISTC_MEM_LVL, 21 + 3);
 153         hists__new_col_len(hists, HISTC_LOCAL_WEIGHT, 12);
 154         hists__new_col_len(hists, HISTC_GLOBAL_WEIGHT, 12);
 155
 156         if (h->transaction)
 157                 hists__new_col_len(hists, HISTC_TRANSACTION,
 158                                    hist_entry__transaction_len());
 159 }
 160
 161 void hists__output_recalc_col_len(struct hists *hists, int max_rows)
 162 {
 163         struct rb_node *next = rb_first(&hists->entries);
 164         struct hist_entry *n;
 165         int row = 0;
 166
 167         hists__reset_col_len(hists);
 168
 169         while (next && row++ < max_rows) {
 170                 n = rb_entry(next, struct hist_entry, rb_node);
 171                 if (!n->filtered)
 172                         hists__calc_col_len(hists, n);
 173                 next = rb_next(&n->rb_node);
 174         }
 175 }
 176
 177 static void he_stat__add_cpumode_period(struct he_stat *he_stat,
 178                                         unsigned int cpumode, u64 period)
 179 {
 180         switch (cpumode) {
 181         case PERF_RECORD_MISC_KERNEL:
 182                 he_stat->period_sys += period;
 183                 break;
 184         case PERF_RECORD_MISC_USER:
 185                 he_stat->period_us += period;
 186                 break;
 187         case PERF_RECORD_MISC_GUEST_KERNEL:
 188                 he_stat->period_guest_sys += period;
 189                 break;
 190         case PERF_RECORD_MISC_GUEST_USER:
 191                 he_stat->period_guest_us += period;
 192                 break;
 193         default:
 194                 break;
 195         }
 196 }
 197
 198 static void he_stat__add_period(struct he_stat *he_stat, u64 period,
 199                                 u64 weight)
 200 {
 201
 202         he_stat->period         += period;
 203         he_stat->weight         += weight;
 204         he_stat->nr_events      += 1;
 205 }
 206
 207 static void he_stat__add_stat(struct he_stat *dest, struct he_stat *src)
 208 {
 209         dest->period            += src->period;
 210         dest->period_sys        += src->period_sys;
 211         dest->period_us         += src->period_us;
 212         dest->period_guest_sys  += src->period_guest_sys;
 213         dest->period_guest_us   += src->period_guest_us;
 214         dest->nr_events         += src->nr_events;
 215         dest->weight            += src->weight;
 216 }
 217
 218 static void he_stat__decay(struct he_stat *he_stat)
 219 {
 220         he_stat->period = (he_stat->period * 7) / 8;
 221         he_stat->nr_events = (he_stat->nr_events * 7) / 8;
 222         /* XXX need decay for weight too? */
 223 }
 224
 225 static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
 226 {
 227         u64 prev_period = he->stat.period;
 228
 229         if (prev_period == 0)
 230                 return true;
 231
 232         he_stat__decay(&he->stat);
 233
 234         if (!he->filtered)
 235                 hists->stats.total_period -= prev_period - he->stat.period;
 236
 237         return he->stat.period == 0;
 238 }
 239
 240 void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
 241 {
 242         struct rb_node *next = rb_first(&hists->entries);
 243         struct hist_entry *n;
 244
 245         while (next) {
 246                 n = rb_entry(next, struct hist_entry, rb_node);
 247                 next = rb_next(&n->rb_node);
 248                 /*
 249                  * We may be annotating this, for instance, so keep it here in
 250                  * case some it gets new samples, we'll eventually free it when
 251                  * the user stops browsing and it agains gets fully decayed.
 252                  */
 253                 if (((zap_user && n->level == '.') ||
 254                      (zap_kernel && n->level != '.') ||
 255                      hists__decay_entry(hists, n)) &&
 256                     !n->used) {
 257                         rb_erase(&n->rb_node, &hists->entries);
 258
 259                         if (sort__need_collapse)
 260                                 rb_erase(&n->rb_node_in, &hists->entries_collapsed);
 261
 262                         hist_entry__free(n);
 263                         --hists->nr_entries;
 264                 }
 265         }
 266 }
 267
 268 /*
 269  * histogram, sorted on item, collects periods
 270  */
 271
 272 static struct hist_entry *hist_entry__new(struct hist_entry *template)
 273 {
 274         size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_root) : 0;
 275         struct hist_entry *he = zalloc(sizeof(*he) + callchain_size);
 276
 277         if (he != NULL) {
 278                 *he = *template;
 279
 280                 if (he->ms.map)
 281                         he->ms.map->referenced = true;
 282
 283                 if (he->branch_info) {
 284                         /*
 285                          * This branch info is (a part of) allocated from
 286                          * sample__resolve_bstack() and will be freed after
 287                          * adding new entries.  So we need to save a copy.
 288                          */
 289                         he->branch_info = malloc(sizeof(*he->branch_info));
 290                         if (he->branch_info == NULL) {
 291                                 free(he);
 292                                 return NULL;
 293                         }
 294
 295                         memcpy(he->branch_info, template->branch_info,
 296                                sizeof(*he->branch_info));
 297
 298                         if (he->branch_info->from.map)
 299                                 he->branch_info->from.map->referenced = true;
 300                         if (he->branch_info->to.map)
 301                                 he->branch_info->to.map->referenced = true;
 302                 }
 303
 304                 if (he->mem_info) {
 305                         if (he->mem_info->iaddr.map)
 306                                 he->mem_info->iaddr.map->referenced = true;
 307                         if (he->mem_info->daddr.map)
 308                                 he->mem_info->daddr.map->referenced = true;
 309                 }
 310
 311                 if (symbol_conf.use_callchain)
 312                         callchain_init(he->callchain);
 313
 314                 INIT_LIST_HEAD(&he->pairs.node);
 315         }
 316
 317         return he;
 318 }
 319
 320 void hists__inc_stats(struct hists *hists, struct hist_entry *h)
 321 {
 322         if (!h->filtered) {
 323                 hists->nr_non_filtered_entries++;
 324                 hists->stats.total_non_filtered_period += h->stat.period;
 325         }
 326         hists->nr_entries++;
 327         hists->stats.total_period += h->stat.period;
 328 }
 329
 330 static u8 symbol__parent_filter(const struct symbol *parent)
 331 {
 332         if (symbol_conf.exclude_other && parent == NULL)
 333                 return 1 << HIST_FILTER__PARENT;
 334         return 0;
 335 }
 336
 337 static struct hist_entry *add_hist_entry(struct hists *hists,
 338                                          struct hist_entry *entry,
 339                                          struct addr_location *al)
 340 {
 341         struct rb_node **p;
 342         struct rb_node *parent = NULL;
 343         struct hist_entry *he;
 344         int64_t cmp;
 345         u64 period = entry->stat.period;
 346         u64 weight = entry->stat.weight;
 347
 348         p = &hists->entries_in->rb_node;
 349
 350         while (*p != NULL) {
 351                 parent = *p;
 352                 he = rb_entry(parent, struct hist_entry, rb_node_in);
 353
 354                 /*
 355                  * Make sure that it receives arguments in a same order as
 356                  * hist_entry__collapse() so that we can use an appropriate
 357                  * function when searching an entry regardless which sort
 358                  * keys were used.
 359                  */
 360                 cmp = hist_entry__cmp(he, entry);
 361
 362                 if (!cmp) {
 363                         he_stat__add_period(&he->stat, period, weight);
 364
 365                         /*
 366                          * This mem info was allocated from sample__resolve_mem
 367                          * and will not be used anymore.
 368                          */
 369                         zfree(&entry->mem_info);
 370
 371                         /* If the map of an existing hist_entry has
 372                          * become out-of-date due to an exec() or
 373                          * similar, update it.  Otherwise we will
 374                          * mis-adjust symbol addresses when computing
 375                          * the history counter to increment.
 376                          */
 377                         if (he->ms.map != entry->ms.map) {
 378                                 he->ms.map = entry->ms.map;
 379                                 if (he->ms.map)
 380                                         he->ms.map->referenced = true;
 381                         }
 382                         goto out;
 383                 }
 384
 385                 if (cmp < 0)
 386                         p = &(*p)->rb_left;
 387                 else
 388                         p = &(*p)->rb_right;
 389         }
 390
 391         he = hist_entry__new(entry);
 392         if (!he)
 393                 return NULL;
 394
 395         hists->nr_entries++;
 396         rb_link_node(&he->rb_node_in, parent, p);
 397         rb_insert_color(&he->rb_node_in, hists->entries_in);
 398 out:
 399         he_stat__add_cpumode_period(&he->stat, al->cpumode, period);
 400         return he;
 401 }
 402
 403 struct hist_entry *__hists__add_entry(struct hists *hists,
 404                                       struct addr_location *al,
 405                                       struct symbol *sym_parent,
 406                                       struct branch_info *bi,
 407                                       struct mem_info *mi,
 408                                       u64 period, u64 weight, u64 transaction)
 409 {
 410         struct hist_entry entry = {
 411                 .thread = al->thread,
 412                 .comm = thread__comm(al->thread),
 413                 .ms = {
 414                         .map    = al->map,
 415                         .sym    = al->sym,
 416                 },
 417                 .cpu    = al->cpu,
 418                 .ip     = al->addr,
 419                 .level  = al->level,
 420                 .stat = {
 421                         .nr_events = 1,
 422                         .period = period,
 423                         .weight = weight,
 424                 },
 425                 .parent = sym_parent,
 426                 .filtered = symbol__parent_filter(sym_parent) | al->filtered,
 427                 .hists  = hists,
 428                 .branch_info = bi,
 429                 .mem_info = mi,
 430                 .transaction = transaction,
 431         };
 432
 433         return add_hist_entry(hists, &entry, al);
 434 }
 435
 436 int64_t
 437 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
 438 {
 439         struct sort_entry *se;
 440         int64_t cmp = 0;
 441
 442         list_for_each_entry(se, &hist_entry__sort_list, list) {
 443                 cmp = se->se_cmp(left, right);
 444                 if (cmp)
 445                         break;
 446         }
 447
 448         return cmp;
 449 }
 450
 451 int64_t
 452 hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
 453 {
 454         struct sort_entry *se;
 455         int64_t cmp = 0;
 456
 457         list_for_each_entry(se, &hist_entry__sort_list, list) {
 458                 int64_t (*f)(struct hist_entry *, struct hist_entry *);
 459
 460                 f = se->se_collapse ?: se->se_cmp;
 461
 462                 cmp = f(left, right);
 463                 if (cmp)
 464                         break;
 465         }
 466
 467         return cmp;
 468 }
 469
 470 void hist_entry__free(struct hist_entry *he)
 471 {
 472         zfree(&he->branch_info);
 473         zfree(&he->mem_info);
 474         free_srcline(he->srcline);
 475         free(he);
 476 }
 477
 478 /*
 479  * collapse the histogram
 480  */
 481
 482 static bool hists__collapse_insert_entry(struct hists *hists __maybe_unused,
 483                                          struct rb_root *root,
 484                                          struct hist_entry *he)
 485 {
 486         struct rb_node **p = &root->rb_node;
 487         struct rb_node *parent = NULL;
 488         struct hist_entry *iter;
 489         int64_t cmp;
 490
 491         while (*p != NULL) {
 492                 parent = *p;
 493                 iter = rb_entry(parent, struct hist_entry, rb_node_in);
 494
 495                 cmp = hist_entry__collapse(iter, he);
 496
 497                 if (!cmp) {
 498                         he_stat__add_stat(&iter->stat, &he->stat);
 499
 500                         if (symbol_conf.use_callchain) {
 501                                 callchain_cursor_reset(&callchain_cursor);
 502                                 callchain_merge(&callchain_cursor,
 503                                                 iter->callchain,
 504                                                 he->callchain);
 505                         }
 506                         hist_entry__free(he);
 507                         return false;
 508                 }
 509
 510                 if (cmp < 0)
 511                         p = &(*p)->rb_left;
 512                 else
 513                         p = &(*p)->rb_right;
 514         }
 515
 516         rb_link_node(&he->rb_node_in, parent, p);
 517         rb_insert_color(&he->rb_node_in, root);
 518         return true;
 519 }
 520
 521 static struct rb_root *hists__get_rotate_entries_in(struct hists *hists)
 522 {
 523         struct rb_root *root;
 524
 525         pthread_mutex_lock(&hists->lock);
 526
 527         root = hists->entries_in;
 528         if (++hists->entries_in > &hists->entries_in_array[1])
 529                 hists->entries_in = &hists->entries_in_array[0];
 530
 531         pthread_mutex_unlock(&hists->lock);
 532
 533         return root;
 534 }
 535
 536 static void hists__apply_filters(struct hists *hists, struct hist_entry *he)
 537 {
 538         hists__filter_entry_by_dso(hists, he);
 539         hists__filter_entry_by_thread(hists, he);
 540         hists__filter_entry_by_symbol(hists, he);
 541 }
 542
 543 void hists__collapse_resort(struct hists *hists, struct ui_progress *prog)
 544 {
 545         struct rb_root *root;
 546         struct rb_node *next;
 547         struct hist_entry *n;
 548
 549         if (!sort__need_collapse)
 550                 return;
 551
 552         root = hists__get_rotate_entries_in(hists);
 553         next = rb_first(root);
 554
 555         while (next) {
 556                 if (session_done())
 557                         break;
 558                 n = rb_entry(next, struct hist_entry, rb_node_in);
 559                 next = rb_next(&n->rb_node_in);
 560
 561                 rb_erase(&n->rb_node_in, root);
 562                 if (hists__collapse_insert_entry(hists, &hists->entries_collapsed, n)) {
 563                         /*
 564                          * If it wasn't combined with one of the entries already
 565                          * collapsed, we need to apply the filters that may have
 566                          * been set by, say, the hist_browser.
 567                          */
 568                         hists__apply_filters(hists, n);
 569                 }
 570                 if (prog)
 571                         ui_progress__update(prog, 1);
 572         }
 573 }
 574
 575 /*
 576  * reverse the map, sort on period.
 577  */
 578
 579 static int period_cmp(u64 period_a, u64 period_b)
 580 {
 581         if (period_a > period_b)
 582                 return 1;
 583         if (period_a < period_b)
 584                 return -1;
 585         return 0;
 586 }
 587
 588 static int hist_entry__sort_on_period(struct hist_entry *a,
 589                                       struct hist_entry *b)
 590 {
 591         int ret;
 592         int i, nr_members;
 593         struct perf_evsel *evsel;
 594         struct hist_entry *pair;
 595         u64 *periods_a, *periods_b;
 596
 597         ret = period_cmp(a->stat.period, b->stat.period);
 598         if (ret || !symbol_conf.event_group)
 599                 return ret;
 600
 601         evsel = hists_to_evsel(a->hists);
 602         nr_members = evsel->nr_members;
 603         if (nr_members <= 1)
 604                 return ret;
 605
 606         periods_a = zalloc(sizeof(periods_a) * nr_members);
 607         periods_b = zalloc(sizeof(periods_b) * nr_members);
 608
 609         if (!periods_a || !periods_b)
 610                 goto out;
 611
 612         list_for_each_entry(pair, &a->pairs.head, pairs.node) {
 613                 evsel = hists_to_evsel(pair->hists);
 614                 periods_a[perf_evsel__group_idx(evsel)] = pair->stat.period;
 615         }
 616
 617         list_for_each_entry(pair, &b->pairs.head, pairs.node) {
 618                 evsel = hists_to_evsel(pair->hists);
 619                 periods_b[perf_evsel__group_idx(evsel)] = pair->stat.period;
 620         }
 621
 622         for (i = 1; i < nr_members; i++) {
 623                 ret = period_cmp(periods_a[i], periods_b[i]);
 624                 if (ret)
 625                         break;
 626         }
 627
 628 out:
 629         free(periods_a);
 630         free(periods_b);
 631
 632         return ret;
 633 }
 634
 635 static void __hists__insert_output_entry(struct rb_root *entries,
 636                                          struct hist_entry *he,
 637                                          u64 min_callchain_hits)
 638 {
 639         struct rb_node **p = &entries->rb_node;
 640         struct rb_node *parent = NULL;
 641         struct hist_entry *iter;
 642
 643         if (symbol_conf.use_callchain)
 644                 callchain_param.sort(&he->sorted_chain, he->callchain,
 645                                       min_callchain_hits, &callchain_param);
 646
 647         while (*p != NULL) {
 648                 parent = *p;
 649                 iter = rb_entry(parent, struct hist_entry, rb_node);
 650
 651                 if (hist_entry__sort_on_period(he, iter) > 0)
 652                         p = &(*p)->rb_left;
 653                 else
 654                         p = &(*p)->rb_right;
 655         }
 656
 657         rb_link_node(&he->rb_node, parent, p);
 658         rb_insert_color(&he->rb_node, entries);
 659 }
 660
 661 void hists__output_resort(struct hists *hists)
 662 {
 663         struct rb_root *root;
 664         struct rb_node *next;
 665         struct hist_entry *n;
 666         u64 min_callchain_hits;
 667
 668         min_callchain_hits = hists->stats.total_period * (callchain_param.min_percent / 100);
 669
 670         if (sort__need_collapse)
 671                 root = &hists->entries_collapsed;
 672         else
 673                 root = hists->entries_in;
 674
 675         next = rb_first(root);
 676         hists->entries = RB_ROOT;
 677
 678         hists->nr_non_filtered_entries = 0;
 679         hists->stats.total_period = 0;
 680         hists->stats.total_non_filtered_period = 0;
 681         hists__reset_col_len(hists);
 682
 683         while (next) {
 684                 n = rb_entry(next, struct hist_entry, rb_node_in);
 685                 next = rb_next(&n->rb_node_in);
 686
 687                 __hists__insert_output_entry(&hists->entries, n, min_callchain_hits);
 688                 hists__inc_stats(hists, n);
 689
 690                 if (!n->filtered)
 691                         hists__calc_col_len(hists, n);
 692         }
 693 }
 694
 695 static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h,
 696                                        enum hist_filter filter)
 697 {
 698         h->filtered &= ~(1 << filter);
 699         if (h->filtered)
 700                 return;
 701
 702         ++hists->nr_non_filtered_entries;
 703         if (h->ms.unfolded)
 704                 hists->nr_non_filtered_entries += h->nr_rows;
 705         h->row_offset = 0;
 706         hists->stats.total_non_filtered_period += h->stat.period;
 707         hists->stats.nr_non_filtered_samples += h->stat.nr_events;
 708
 709         hists__calc_col_len(hists, h);
 710 }
 711
 712
 713 static bool hists__filter_entry_by_dso(struct hists *hists,
 714                                        struct hist_entry *he)
 715 {
 716         if (hists->dso_filter != NULL &&
 717             (he->ms.map == NULL || he->ms.map->dso != hists->dso_filter)) {
 718                 he->filtered |= (1 << HIST_FILTER__DSO);
 719                 return true;
 720         }
 721
 722         return false;
 723 }
 724
 725 void hists__filter_by_dso(struct hists *hists)
 726 {
 727         struct rb_node *nd;
 728
 729         hists->nr_non_filtered_entries = 0;
 730         hists->stats.total_non_filtered_period = 0;
 731         hists->stats.nr_non_filtered_samples = 0;
 732         hists__reset_col_len(hists);
 733
 734         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
 735                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 736
 737                 if (symbol_conf.exclude_other && !h->parent)
 738                         continue;
 739
 740                 if (hists__filter_entry_by_dso(hists, h))
 741                         continue;
 742
 743                 hists__remove_entry_filter(hists, h, HIST_FILTER__DSO);
 744         }
 745 }
 746
 747 static bool hists__filter_entry_by_thread(struct hists *hists,
 748                                           struct hist_entry *he)
 749 {
 750         if (hists->thread_filter != NULL &&
 751             he->thread != hists->thread_filter) {
 752                 he->filtered |= (1 << HIST_FILTER__THREAD);
 753                 return true;
 754         }
 755
 756         return false;
 757 }
 758
 759 void hists__filter_by_thread(struct hists *hists)
 760 {
 761         struct rb_node *nd;
 762
 763         hists->nr_non_filtered_entries = 0;
 764         hists->stats.total_non_filtered_period = 0;
 765         hists->stats.nr_non_filtered_samples = 0;
 766         hists__reset_col_len(hists);
 767
 768         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
 769                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 770
 771                 if (hists__filter_entry_by_thread(hists, h))
 772                         continue;
 773
 774                 hists__remove_entry_filter(hists, h, HIST_FILTER__THREAD);
 775         }
 776 }
 777
 778 static bool hists__filter_entry_by_symbol(struct hists *hists,
 779                                           struct hist_entry *he)
 780 {
 781         if (hists->symbol_filter_str != NULL &&
 782             (!he->ms.sym || strstr(he->ms.sym->name,
 783                                    hists->symbol_filter_str) == NULL)) {
 784                 he->filtered |= (1 << HIST_FILTER__SYMBOL);
 785                 return true;
 786         }
 787
 788         return false;
 789 }
 790
 791 void hists__filter_by_symbol(struct hists *hists)
 792 {
 793         struct rb_node *nd;
 794
 795         hists->nr_non_filtered_entries = 0;
 796         hists->stats.total_non_filtered_period = 0;
 797         hists->stats.nr_non_filtered_samples = 0;
 798         hists__reset_col_len(hists);
 799
 800         for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
 801                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 802
 803                 if (hists__filter_entry_by_symbol(hists, h))
 804                         continue;
 805
 806                 hists__remove_entry_filter(hists, h, HIST_FILTER__SYMBOL);
 807         }
 808 }
 809
 810 void events_stats__inc(struct events_stats *stats, u32 type)
 811 {
 812         ++stats->nr_events[0];
 813         ++stats->nr_events[type];
 814 }
 815
 816 void hists__inc_nr_events(struct hists *hists, u32 type)
 817 {
 818         events_stats__inc(&hists->stats, type);
 819 }
 820
 821 static struct hist_entry *hists__add_dummy_entry(struct hists *hists,
 822                                                  struct hist_entry *pair)
 823 {
 824         struct rb_root *root;
 825         struct rb_node **p;
 826         struct rb_node *parent = NULL;
 827         struct hist_entry *he;
 828         int64_t cmp;
 829
 830         if (sort__need_collapse)
 831                 root = &hists->entries_collapsed;
 832         else
 833                 root = hists->entries_in;
 834
 835         p = &root->rb_node;
 836
 837         while (*p != NULL) {
 838                 parent = *p;
 839                 he = rb_entry(parent, struct hist_entry, rb_node_in);
 840
 841                 cmp = hist_entry__collapse(he, pair);
 842
 843                 if (!cmp)
 844                         goto out;
 845
 846                 if (cmp < 0)
 847                         p = &(*p)->rb_left;
 848                 else
 849                         p = &(*p)->rb_right;
 850         }
 851
 852         he = hist_entry__new(pair);
 853         if (he) {
 854                 memset(&he->stat, 0, sizeof(he->stat));
 855                 he->hists = hists;
 856                 rb_link_node(&he->rb_node_in, parent, p);
 857                 rb_insert_color(&he->rb_node_in, root);
 858                 hists__inc_stats(hists, he);
 859                 he->dummy = true;
 860         }
 861 out:
 862         return he;
 863 }
 864
 865 static struct hist_entry *hists__find_entry(struct hists *hists,
 866                                             struct hist_entry *he)
 867 {
 868         struct rb_node *n;
 869
 870         if (sort__need_collapse)
 871                 n = hists->entries_collapsed.rb_node;
 872         else
 873                 n = hists->entries_in->rb_node;
 874
 875         while (n) {
 876                 struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node_in);
 877                 int64_t cmp = hist_entry__collapse(iter, he);
 878
 879                 if (cmp < 0)
 880                         n = n->rb_left;
 881                 else if (cmp > 0)
 882                         n = n->rb_right;
 883                 else
 884                         return iter;
 885         }
 886
 887         return NULL;
 888 }
 889
 890 /*
 891  * Look for pairs to link to the leader buckets (hist_entries):
 892  */
 893 void hists__match(struct hists *leader, struct hists *other)
 894 {
 895         struct rb_root *root;
 896         struct rb_node *nd;
 897         struct hist_entry *pos, *pair;
 898
 899         if (sort__need_collapse)
 900                 root = &leader->entries_collapsed;
 901         else
 902                 root = leader->entries_in;
 903
 904         for (nd = rb_first(root); nd; nd = rb_next(nd)) {
 905                 pos  = rb_entry(nd, struct hist_entry, rb_node_in);
 906                 pair = hists__find_entry(other, pos);
 907
 908                 if (pair)
 909                         hist_entry__add_pair(pair, pos);
 910         }
 911 }
 912
 913 /*
 914  * Look for entries in the other hists that are not present in the leader, if
 915  * we find them, just add a dummy entry on the leader hists, with period=0,
 916  * nr_events=0, to serve as the list header.
 917  */
 918 int hists__link(struct hists *leader, struct hists *other)
 919 {
 920         struct rb_root *root;
 921         struct rb_node *nd;
 922         struct hist_entry *pos, *pair;
 923
 924         if (sort__need_collapse)
 925                 root = &other->entries_collapsed;
 926         else
 927                 root = other->entries_in;
 928
 929         for (nd = rb_first(root); nd; nd = rb_next(nd)) {
 930                 pos = rb_entry(nd, struct hist_entry, rb_node_in);
 931
 932                 if (!hist_entry__has_pairs(pos)) {
 933                         pair = hists__add_dummy_entry(leader, pos);
 934                         if (pair == NULL)
 935                                 return -1;
 936                         hist_entry__add_pair(pos, pair);
 937                 }
 938         }
 939
 940         return 0;
 941 }
 942
 943 u64 hists__total_period(struct hists *hists)
 944 {
 945         return symbol_conf.filter_relative ? hists->stats.total_non_filtered_period :
 946                 hists->stats.total_period;
 947 }
 948
 949 int parse_filter_percentage(const struct option *opt __maybe_unused,
 950                             const char *arg, int unset __maybe_unused)
 951 {
 952         if (!strcmp(arg, "relative"))
 953                 symbol_conf.filter_relative = true;
 954         else if (!strcmp(arg, "absolute"))
 955                 symbol_conf.filter_relative = false;
 956         else
 957                 return -1;
 958
 959         return 0;
 960 }
 961
 962 int perf_hist_config(const char *var, const char *value)
 963 {
 964         if (!strcmp(var, "hist.percentage"))
 965                 return parse_filter_percentage(NULL, value, 0);
 966
 967         return 0;
 968 }