1 #include "annotate.h" 2 #include "util.h" 3 #include "build-id.h" 4 #include "hist.h" 5 #include "session.h" 6 #include "sort.h" 7 #include <math.h> 8 9 enum hist_filter { 10 HIST_FILTER__DSO, 11 HIST_FILTER__THREAD, 12 HIST_FILTER__PARENT, 13 }; 14 15 struct callchain_param callchain_param = { 16 .mode = CHAIN_GRAPH_REL, 17 .min_percent = 0.5, 18 .order = ORDER_CALLEE 19 }; 20 21 u16 hists__col_len(struct hists *self, enum hist_column col) 22 { 23 return self->col_len[col]; 24 } 25 26 void hists__set_col_len(struct hists *self, enum hist_column col, u16 len) 27 { 28 self->col_len[col] = len; 29 } 30 31 bool hists__new_col_len(struct hists *self, enum hist_column col, u16 len) 32 { 33 if (len > hists__col_len(self, col)) { 34 hists__set_col_len(self, col, len); 35 return true; 36 } 37 return false; 38 } 39 40 static void hists__reset_col_len(struct hists *self) 41 { 42 enum hist_column col; 43 44 for (col = 0; col < HISTC_NR_COLS; ++col) 45 hists__set_col_len(self, col, 0); 46 } 47 48 static void hists__calc_col_len(struct hists *self, struct hist_entry *h) 49 { 50 u16 len; 51 52 if (h->ms.sym) 53 hists__new_col_len(self, HISTC_SYMBOL, h->ms.sym->namelen); 54 else { 55 const unsigned int unresolved_col_width = BITS_PER_LONG / 4; 56 57 if (hists__col_len(self, HISTC_DSO) < unresolved_col_width && 58 !symbol_conf.col_width_list_str && !symbol_conf.field_sep && 59 !symbol_conf.dso_list) 60 hists__set_col_len(self, HISTC_DSO, 61 unresolved_col_width); 62 } 63 64 len = thread__comm_len(h->thread); 65 if (hists__new_col_len(self, HISTC_COMM, len)) 66 hists__set_col_len(self, HISTC_THREAD, len + 6); 67 68 if (h->ms.map) { 69 len = dso__name_len(h->ms.map->dso); 70 hists__new_col_len(self, HISTC_DSO, len); 71 } 72 } 73 74 static void hist_entry__add_cpumode_period(struct hist_entry *self, 75 unsigned int cpumode, u64 period) 76 { 77 switch (cpumode) { 78 case PERF_RECORD_MISC_KERNEL: 79 self->period_sys += period; 80 break; 81 case PERF_RECORD_MISC_USER: 82 self->period_us += period; 83 break; 84 case PERF_RECORD_MISC_GUEST_KERNEL: 85 self->period_guest_sys += period; 86 break; 87 case PERF_RECORD_MISC_GUEST_USER: 88 self->period_guest_us += period; 89 break; 90 default: 91 break; 92 } 93 } 94 95 /* 96 * histogram, sorted on item, collects periods 97 */ 98 99 static struct hist_entry *hist_entry__new(struct hist_entry *template) 100 { 101 size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_root) : 0; 102 struct hist_entry *self = malloc(sizeof(*self) + callchain_size); 103 104 if (self != NULL) { 105 *self = *template; 106 self->nr_events = 1; 107 if (self->ms.map) 108 self->ms.map->referenced = true; 109 if (symbol_conf.use_callchain) 110 callchain_init(self->callchain); 111 } 112 113 return self; 114 } 115 116 static void hists__inc_nr_entries(struct hists *self, struct hist_entry *h) 117 { 118 if (!h->filtered) { 119 hists__calc_col_len(self, h); 120 ++self->nr_entries; 121 } 122 } 123 124 static u8 symbol__parent_filter(const struct symbol *parent) 125 { 126 if (symbol_conf.exclude_other && parent == NULL) 127 return 1 << HIST_FILTER__PARENT; 128 return 0; 129 } 130 131 struct hist_entry *__hists__add_entry(struct hists *self, 132 struct addr_location *al, 133 struct symbol *sym_parent, u64 period) 134 { 135 struct rb_node **p = &self->entries.rb_node; 136 struct rb_node *parent = NULL; 137 struct hist_entry *he; 138 struct hist_entry entry = { 139 .thread = al->thread, 140 .ms = { 141 .map = al->map, 142 .sym = al->sym, 143 }, 144 .cpu = al->cpu, 145 .ip = al->addr, 146 .level = al->level, 147 .period = period, 148 .parent = sym_parent, 149 .filtered = symbol__parent_filter(sym_parent), 150 }; 151 int cmp; 152 153 while (*p != NULL) { 154 parent = *p; 155 he = rb_entry(parent, struct hist_entry, rb_node); 156 157 cmp = hist_entry__cmp(&entry, he); 158 159 if (!cmp) { 160 he->period += period; 161 ++he->nr_events; 162 goto out; 163 } 164 165 if (cmp < 0) 166 p = &(*p)->rb_left; 167 else 168 p = &(*p)->rb_right; 169 } 170 171 he = hist_entry__new(&entry); 172 if (!he) 173 return NULL; 174 rb_link_node(&he->rb_node, parent, p); 175 rb_insert_color(&he->rb_node, &self->entries); 176 hists__inc_nr_entries(self, he); 177 out: 178 hist_entry__add_cpumode_period(he, al->cpumode, period); 179 return he; 180 } 181 182 int64_t 183 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right) 184 { 185 struct sort_entry *se; 186 int64_t cmp = 0; 187 188 list_for_each_entry(se, &hist_entry__sort_list, list) { 189 cmp = se->se_cmp(left, right); 190 if (cmp) 191 break; 192 } 193 194 return cmp; 195 } 196 197 int64_t 198 hist_entry__collapse(struct hist_entry *left, struct hist_entry *right) 199 { 200 struct sort_entry *se; 201 int64_t cmp = 0; 202 203 list_for_each_entry(se, &hist_entry__sort_list, list) { 204 int64_t (*f)(struct hist_entry *, struct hist_entry *); 205 206 f = se->se_collapse ?: se->se_cmp; 207 208 cmp = f(left, right); 209 if (cmp) 210 break; 211 } 212 213 return cmp; 214 } 215 216 void hist_entry__free(struct hist_entry *he) 217 { 218 free(he); 219 } 220 221 /* 222 * collapse the histogram 223 */ 224 225 static bool hists__collapse_insert_entry(struct hists *self, 226 struct rb_root *root, 227 struct hist_entry *he) 228 { 229 struct rb_node **p = &root->rb_node; 230 struct rb_node *parent = NULL; 231 struct hist_entry *iter; 232 int64_t cmp; 233 234 while (*p != NULL) { 235 parent = *p; 236 iter = rb_entry(parent, struct hist_entry, rb_node); 237 238 cmp = hist_entry__collapse(iter, he); 239 240 if (!cmp) { 241 iter->period += he->period; 242 if (symbol_conf.use_callchain) { 243 callchain_cursor_reset(&self->callchain_cursor); 244 callchain_merge(&self->callchain_cursor, iter->callchain, 245 he->callchain); 246 } 247 hist_entry__free(he); 248 return false; 249 } 250 251 if (cmp < 0) 252 p = &(*p)->rb_left; 253 else 254 p = &(*p)->rb_right; 255 } 256 257 rb_link_node(&he->rb_node, parent, p); 258 rb_insert_color(&he->rb_node, root); 259 return true; 260 } 261 262 void hists__collapse_resort(struct hists *self) 263 { 264 struct rb_root tmp; 265 struct rb_node *next; 266 struct hist_entry *n; 267 268 if (!sort__need_collapse) 269 return; 270 271 tmp = RB_ROOT; 272 next = rb_first(&self->entries); 273 self->nr_entries = 0; 274 hists__reset_col_len(self); 275 276 while (next) { 277 n = rb_entry(next, struct hist_entry, rb_node); 278 next = rb_next(&n->rb_node); 279 280 rb_erase(&n->rb_node, &self->entries); 281 if (hists__collapse_insert_entry(self, &tmp, n)) 282 hists__inc_nr_entries(self, n); 283 } 284 285 self->entries = tmp; 286 } 287 288 /* 289 * reverse the map, sort on period. 290 */ 291 292 static void __hists__insert_output_entry(struct rb_root *entries, 293 struct hist_entry *he, 294 u64 min_callchain_hits) 295 { 296 struct rb_node **p = &entries->rb_node; 297 struct rb_node *parent = NULL; 298 struct hist_entry *iter; 299 300 if (symbol_conf.use_callchain) 301 callchain_param.sort(&he->sorted_chain, he->callchain, 302 min_callchain_hits, &callchain_param); 303 304 while (*p != NULL) { 305 parent = *p; 306 iter = rb_entry(parent, struct hist_entry, rb_node); 307 308 if (he->period > iter->period) 309 p = &(*p)->rb_left; 310 else 311 p = &(*p)->rb_right; 312 } 313 314 rb_link_node(&he->rb_node, parent, p); 315 rb_insert_color(&he->rb_node, entries); 316 } 317 318 void hists__output_resort(struct hists *self) 319 { 320 struct rb_root tmp; 321 struct rb_node *next; 322 struct hist_entry *n; 323 u64 min_callchain_hits; 324 325 min_callchain_hits = self->stats.total_period * (callchain_param.min_percent / 100); 326 327 tmp = RB_ROOT; 328 next = rb_first(&self->entries); 329 330 self->nr_entries = 0; 331 hists__reset_col_len(self); 332 333 while (next) { 334 n = rb_entry(next, struct hist_entry, rb_node); 335 next = rb_next(&n->rb_node); 336 337 rb_erase(&n->rb_node, &self->entries); 338 __hists__insert_output_entry(&tmp, n, min_callchain_hits); 339 hists__inc_nr_entries(self, n); 340 } 341 342 self->entries = tmp; 343 } 344 345 static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin) 346 { 347 int i; 348 int ret = fprintf(fp, " "); 349 350 for (i = 0; i < left_margin; i++) 351 ret += fprintf(fp, " "); 352 353 return ret; 354 } 355 356 static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask, 357 int left_margin) 358 { 359 int i; 360 size_t ret = callchain__fprintf_left_margin(fp, left_margin); 361 362 for (i = 0; i < depth; i++) 363 if (depth_mask & (1 << i)) 364 ret += fprintf(fp, "| "); 365 else 366 ret += fprintf(fp, " "); 367 368 ret += fprintf(fp, "\n"); 369 370 return ret; 371 } 372 373 static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain, 374 int depth, int depth_mask, int period, 375 u64 total_samples, u64 hits, 376 int left_margin) 377 { 378 int i; 379 size_t ret = 0; 380 381 ret += callchain__fprintf_left_margin(fp, left_margin); 382 for (i = 0; i < depth; i++) { 383 if (depth_mask & (1 << i)) 384 ret += fprintf(fp, "|"); 385 else 386 ret += fprintf(fp, " "); 387 if (!period && i == depth - 1) { 388 double percent; 389 390 percent = hits * 100.0 / total_samples; 391 ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent); 392 } else 393 ret += fprintf(fp, "%s", " "); 394 } 395 if (chain->ms.sym) 396 ret += fprintf(fp, "%s\n", chain->ms.sym->name); 397 else 398 ret += fprintf(fp, "%p\n", (void *)(long)chain->ip); 399 400 return ret; 401 } 402 403 static struct symbol *rem_sq_bracket; 404 static struct callchain_list rem_hits; 405 406 static void init_rem_hits(void) 407 { 408 rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6); 409 if (!rem_sq_bracket) { 410 fprintf(stderr, "Not enough memory to display remaining hits\n"); 411 return; 412 } 413 414 strcpy(rem_sq_bracket->name, "[...]"); 415 rem_hits.ms.sym = rem_sq_bracket; 416 } 417 418 static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self, 419 u64 total_samples, int depth, 420 int depth_mask, int left_margin) 421 { 422 struct rb_node *node, *next; 423 struct callchain_node *child; 424 struct callchain_list *chain; 425 int new_depth_mask = depth_mask; 426 u64 new_total; 427 u64 remaining; 428 size_t ret = 0; 429 int i; 430 uint entries_printed = 0; 431 432 if (callchain_param.mode == CHAIN_GRAPH_REL) 433 new_total = self->children_hit; 434 else 435 new_total = total_samples; 436 437 remaining = new_total; 438 439 node = rb_first(&self->rb_root); 440 while (node) { 441 u64 cumul; 442 443 child = rb_entry(node, struct callchain_node, rb_node); 444 cumul = callchain_cumul_hits(child); 445 remaining -= cumul; 446 447 /* 448 * The depth mask manages the output of pipes that show 449 * the depth. We don't want to keep the pipes of the current 450 * level for the last child of this depth. 451 * Except if we have remaining filtered hits. They will 452 * supersede the last child 453 */ 454 next = rb_next(node); 455 if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining)) 456 new_depth_mask &= ~(1 << (depth - 1)); 457 458 /* 459 * But we keep the older depth mask for the line separator 460 * to keep the level link until we reach the last child 461 */ 462 ret += ipchain__fprintf_graph_line(fp, depth, depth_mask, 463 left_margin); 464 i = 0; 465 list_for_each_entry(chain, &child->val, list) { 466 ret += ipchain__fprintf_graph(fp, chain, depth, 467 new_depth_mask, i++, 468 new_total, 469 cumul, 470 left_margin); 471 } 472 ret += __callchain__fprintf_graph(fp, child, new_total, 473 depth + 1, 474 new_depth_mask | (1 << depth), 475 left_margin); 476 node = next; 477 if (++entries_printed == callchain_param.print_limit) 478 break; 479 } 480 481 if (callchain_param.mode == CHAIN_GRAPH_REL && 482 remaining && remaining != new_total) { 483 484 if (!rem_sq_bracket) 485 return ret; 486 487 new_depth_mask &= ~(1 << (depth - 1)); 488 489 ret += ipchain__fprintf_graph(fp, &rem_hits, depth, 490 new_depth_mask, 0, new_total, 491 remaining, left_margin); 492 } 493 494 return ret; 495 } 496 497 static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self, 498 u64 total_samples, int left_margin) 499 { 500 struct callchain_list *chain; 501 bool printed = false; 502 int i = 0; 503 int ret = 0; 504 u32 entries_printed = 0; 505 506 list_for_each_entry(chain, &self->val, list) { 507 if (!i++ && sort__first_dimension == SORT_SYM) 508 continue; 509 510 if (!printed) { 511 ret += callchain__fprintf_left_margin(fp, left_margin); 512 ret += fprintf(fp, "|\n"); 513 ret += callchain__fprintf_left_margin(fp, left_margin); 514 ret += fprintf(fp, "---"); 515 516 left_margin += 3; 517 printed = true; 518 } else 519 ret += callchain__fprintf_left_margin(fp, left_margin); 520 521 if (chain->ms.sym) 522 ret += fprintf(fp, " %s\n", chain->ms.sym->name); 523 else 524 ret += fprintf(fp, " %p\n", (void *)(long)chain->ip); 525 526 if (++entries_printed == callchain_param.print_limit) 527 break; 528 } 529 530 ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin); 531 532 return ret; 533 } 534 535 static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self, 536 u64 total_samples) 537 { 538 struct callchain_list *chain; 539 size_t ret = 0; 540 541 if (!self) 542 return 0; 543 544 ret += callchain__fprintf_flat(fp, self->parent, total_samples); 545 546 547 list_for_each_entry(chain, &self->val, list) { 548 if (chain->ip >= PERF_CONTEXT_MAX) 549 continue; 550 if (chain->ms.sym) 551 ret += fprintf(fp, " %s\n", chain->ms.sym->name); 552 else 553 ret += fprintf(fp, " %p\n", 554 (void *)(long)chain->ip); 555 } 556 557 return ret; 558 } 559 560 static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self, 561 u64 total_samples, int left_margin) 562 { 563 struct rb_node *rb_node; 564 struct callchain_node *chain; 565 size_t ret = 0; 566 u32 entries_printed = 0; 567 568 rb_node = rb_first(&self->sorted_chain); 569 while (rb_node) { 570 double percent; 571 572 chain = rb_entry(rb_node, struct callchain_node, rb_node); 573 percent = chain->hit * 100.0 / total_samples; 574 switch (callchain_param.mode) { 575 case CHAIN_FLAT: 576 ret += percent_color_fprintf(fp, " %6.2f%%\n", 577 percent); 578 ret += callchain__fprintf_flat(fp, chain, total_samples); 579 break; 580 case CHAIN_GRAPH_ABS: /* Falldown */ 581 case CHAIN_GRAPH_REL: 582 ret += callchain__fprintf_graph(fp, chain, total_samples, 583 left_margin); 584 case CHAIN_NONE: 585 default: 586 break; 587 } 588 ret += fprintf(fp, "\n"); 589 if (++entries_printed == callchain_param.print_limit) 590 break; 591 rb_node = rb_next(rb_node); 592 } 593 594 return ret; 595 } 596 597 int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size, 598 struct hists *hists, struct hists *pair_hists, 599 bool show_displacement, long displacement, 600 bool color, u64 session_total) 601 { 602 struct sort_entry *se; 603 u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us; 604 u64 nr_events; 605 const char *sep = symbol_conf.field_sep; 606 int ret; 607 608 if (symbol_conf.exclude_other && !self->parent) 609 return 0; 610 611 if (pair_hists) { 612 period = self->pair ? self->pair->period : 0; 613 nr_events = self->pair ? self->pair->nr_events : 0; 614 total = pair_hists->stats.total_period; 615 period_sys = self->pair ? self->pair->period_sys : 0; 616 period_us = self->pair ? self->pair->period_us : 0; 617 period_guest_sys = self->pair ? self->pair->period_guest_sys : 0; 618 period_guest_us = self->pair ? self->pair->period_guest_us : 0; 619 } else { 620 period = self->period; 621 nr_events = self->nr_events; 622 total = session_total; 623 period_sys = self->period_sys; 624 period_us = self->period_us; 625 period_guest_sys = self->period_guest_sys; 626 period_guest_us = self->period_guest_us; 627 } 628 629 if (total) { 630 if (color) 631 ret = percent_color_snprintf(s, size, 632 sep ? "%.2f" : " %6.2f%%", 633 (period * 100.0) / total); 634 else 635 ret = snprintf(s, size, sep ? "%.2f" : " %6.2f%%", 636 (period * 100.0) / total); 637 if (symbol_conf.show_cpu_utilization) { 638 ret += percent_color_snprintf(s + ret, size - ret, 639 sep ? "%.2f" : " %6.2f%%", 640 (period_sys * 100.0) / total); 641 ret += percent_color_snprintf(s + ret, size - ret, 642 sep ? "%.2f" : " %6.2f%%", 643 (period_us * 100.0) / total); 644 if (perf_guest) { 645 ret += percent_color_snprintf(s + ret, 646 size - ret, 647 sep ? "%.2f" : " %6.2f%%", 648 (period_guest_sys * 100.0) / 649 total); 650 ret += percent_color_snprintf(s + ret, 651 size - ret, 652 sep ? "%.2f" : " %6.2f%%", 653 (period_guest_us * 100.0) / 654 total); 655 } 656 } 657 } else 658 ret = snprintf(s, size, sep ? "%" PRIu64 : "%12" PRIu64 " ", period); 659 660 if (symbol_conf.show_nr_samples) { 661 if (sep) 662 ret += snprintf(s + ret, size - ret, "%c%" PRIu64, *sep, nr_events); 663 else 664 ret += snprintf(s + ret, size - ret, "%11" PRIu64, nr_events); 665 } 666 667 if (pair_hists) { 668 char bf[32]; 669 double old_percent = 0, new_percent = 0, diff; 670 671 if (total > 0) 672 old_percent = (period * 100.0) / total; 673 if (session_total > 0) 674 new_percent = (self->period * 100.0) / session_total; 675 676 diff = new_percent - old_percent; 677 678 if (fabs(diff) >= 0.01) 679 snprintf(bf, sizeof(bf), "%+4.2F%%", diff); 680 else 681 snprintf(bf, sizeof(bf), " "); 682 683 if (sep) 684 ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf); 685 else 686 ret += snprintf(s + ret, size - ret, "%11.11s", bf); 687 688 if (show_displacement) { 689 if (displacement) 690 snprintf(bf, sizeof(bf), "%+4ld", displacement); 691 else 692 snprintf(bf, sizeof(bf), " "); 693 694 if (sep) 695 ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf); 696 else 697 ret += snprintf(s + ret, size - ret, "%6.6s", bf); 698 } 699 } 700 701 list_for_each_entry(se, &hist_entry__sort_list, list) { 702 if (se->elide) 703 continue; 704 705 ret += snprintf(s + ret, size - ret, "%s", sep ?: " "); 706 ret += se->se_snprintf(self, s + ret, size - ret, 707 hists__col_len(hists, se->se_width_idx)); 708 } 709 710 return ret; 711 } 712 713 int hist_entry__fprintf(struct hist_entry *self, struct hists *hists, 714 struct hists *pair_hists, bool show_displacement, 715 long displacement, FILE *fp, u64 session_total) 716 { 717 char bf[512]; 718 hist_entry__snprintf(self, bf, sizeof(bf), hists, pair_hists, 719 show_displacement, displacement, 720 true, session_total); 721 return fprintf(fp, "%s\n", bf); 722 } 723 724 static size_t hist_entry__fprintf_callchain(struct hist_entry *self, 725 struct hists *hists, FILE *fp, 726 u64 session_total) 727 { 728 int left_margin = 0; 729 730 if (sort__first_dimension == SORT_COMM) { 731 struct sort_entry *se = list_first_entry(&hist_entry__sort_list, 732 typeof(*se), list); 733 left_margin = hists__col_len(hists, se->se_width_idx); 734 left_margin -= thread__comm_len(self->thread); 735 } 736 737 return hist_entry_callchain__fprintf(fp, self, session_total, 738 left_margin); 739 } 740 741 size_t hists__fprintf(struct hists *self, struct hists *pair, 742 bool show_displacement, FILE *fp) 743 { 744 struct sort_entry *se; 745 struct rb_node *nd; 746 size_t ret = 0; 747 unsigned long position = 1; 748 long displacement = 0; 749 unsigned int width; 750 const char *sep = symbol_conf.field_sep; 751 const char *col_width = symbol_conf.col_width_list_str; 752 753 init_rem_hits(); 754 755 fprintf(fp, "# %s", pair ? "Baseline" : "Overhead"); 756 757 if (symbol_conf.show_nr_samples) { 758 if (sep) 759 fprintf(fp, "%cSamples", *sep); 760 else 761 fputs(" Samples ", fp); 762 } 763 764 if (symbol_conf.show_cpu_utilization) { 765 if (sep) { 766 ret += fprintf(fp, "%csys", *sep); 767 ret += fprintf(fp, "%cus", *sep); 768 if (perf_guest) { 769 ret += fprintf(fp, "%cguest sys", *sep); 770 ret += fprintf(fp, "%cguest us", *sep); 771 } 772 } else { 773 ret += fprintf(fp, " sys "); 774 ret += fprintf(fp, " us "); 775 if (perf_guest) { 776 ret += fprintf(fp, " guest sys "); 777 ret += fprintf(fp, " guest us "); 778 } 779 } 780 } 781 782 if (pair) { 783 if (sep) 784 ret += fprintf(fp, "%cDelta", *sep); 785 else 786 ret += fprintf(fp, " Delta "); 787 788 if (show_displacement) { 789 if (sep) 790 ret += fprintf(fp, "%cDisplacement", *sep); 791 else 792 ret += fprintf(fp, " Displ"); 793 } 794 } 795 796 list_for_each_entry(se, &hist_entry__sort_list, list) { 797 if (se->elide) 798 continue; 799 if (sep) { 800 fprintf(fp, "%c%s", *sep, se->se_header); 801 continue; 802 } 803 width = strlen(se->se_header); 804 if (symbol_conf.col_width_list_str) { 805 if (col_width) { 806 hists__set_col_len(self, se->se_width_idx, 807 atoi(col_width)); 808 col_width = strchr(col_width, ','); 809 if (col_width) 810 ++col_width; 811 } 812 } 813 if (!hists__new_col_len(self, se->se_width_idx, width)) 814 width = hists__col_len(self, se->se_width_idx); 815 fprintf(fp, " %*s", width, se->se_header); 816 } 817 fprintf(fp, "\n"); 818 819 if (sep) 820 goto print_entries; 821 822 fprintf(fp, "# ........"); 823 if (symbol_conf.show_nr_samples) 824 fprintf(fp, " .........."); 825 if (pair) { 826 fprintf(fp, " .........."); 827 if (show_displacement) 828 fprintf(fp, " ....."); 829 } 830 list_for_each_entry(se, &hist_entry__sort_list, list) { 831 unsigned int i; 832 833 if (se->elide) 834 continue; 835 836 fprintf(fp, " "); 837 width = hists__col_len(self, se->se_width_idx); 838 if (width == 0) 839 width = strlen(se->se_header); 840 for (i = 0; i < width; i++) 841 fprintf(fp, "."); 842 } 843 844 fprintf(fp, "\n#\n"); 845 846 print_entries: 847 for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) { 848 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); 849 850 if (h->filtered) 851 continue; 852 853 if (show_displacement) { 854 if (h->pair != NULL) 855 displacement = ((long)h->pair->position - 856 (long)position); 857 else 858 displacement = 0; 859 ++position; 860 } 861 ret += hist_entry__fprintf(h, self, pair, show_displacement, 862 displacement, fp, self->stats.total_period); 863 864 if (symbol_conf.use_callchain) 865 ret += hist_entry__fprintf_callchain(h, self, fp, 866 self->stats.total_period); 867 if (h->ms.map == NULL && verbose > 1) { 868 __map_groups__fprintf_maps(&h->thread->mg, 869 MAP__FUNCTION, verbose, fp); 870 fprintf(fp, "%.10s end\n", graph_dotted_line); 871 } 872 } 873 874 free(rem_sq_bracket); 875 876 return ret; 877 } 878 879 /* 880 * See hists__fprintf to match the column widths 881 */ 882 unsigned int hists__sort_list_width(struct hists *self) 883 { 884 struct sort_entry *se; 885 int ret = 9; /* total % */ 886 887 if (symbol_conf.show_cpu_utilization) { 888 ret += 7; /* count_sys % */ 889 ret += 6; /* count_us % */ 890 if (perf_guest) { 891 ret += 13; /* count_guest_sys % */ 892 ret += 12; /* count_guest_us % */ 893 } 894 } 895 896 if (symbol_conf.show_nr_samples) 897 ret += 11; 898 899 list_for_each_entry(se, &hist_entry__sort_list, list) 900 if (!se->elide) 901 ret += 2 + hists__col_len(self, se->se_width_idx); 902 903 if (verbose) /* Addr + origin */ 904 ret += 3 + BITS_PER_LONG / 4; 905 906 return ret; 907 } 908 909 static void hists__remove_entry_filter(struct hists *self, struct hist_entry *h, 910 enum hist_filter filter) 911 { 912 h->filtered &= ~(1 << filter); 913 if (h->filtered) 914 return; 915 916 ++self->nr_entries; 917 if (h->ms.unfolded) 918 self->nr_entries += h->nr_rows; 919 h->row_offset = 0; 920 self->stats.total_period += h->period; 921 self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events; 922 923 hists__calc_col_len(self, h); 924 } 925 926 void hists__filter_by_dso(struct hists *self, const struct dso *dso) 927 { 928 struct rb_node *nd; 929 930 self->nr_entries = self->stats.total_period = 0; 931 self->stats.nr_events[PERF_RECORD_SAMPLE] = 0; 932 hists__reset_col_len(self); 933 934 for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) { 935 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); 936 937 if (symbol_conf.exclude_other && !h->parent) 938 continue; 939 940 if (dso != NULL && (h->ms.map == NULL || h->ms.map->dso != dso)) { 941 h->filtered |= (1 << HIST_FILTER__DSO); 942 continue; 943 } 944 945 hists__remove_entry_filter(self, h, HIST_FILTER__DSO); 946 } 947 } 948 949 void hists__filter_by_thread(struct hists *self, const struct thread *thread) 950 { 951 struct rb_node *nd; 952 953 self->nr_entries = self->stats.total_period = 0; 954 self->stats.nr_events[PERF_RECORD_SAMPLE] = 0; 955 hists__reset_col_len(self); 956 957 for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) { 958 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); 959 960 if (thread != NULL && h->thread != thread) { 961 h->filtered |= (1 << HIST_FILTER__THREAD); 962 continue; 963 } 964 965 hists__remove_entry_filter(self, h, HIST_FILTER__THREAD); 966 } 967 } 968 969 int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip) 970 { 971 return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip); 972 } 973 974 int hist_entry__annotate(struct hist_entry *he, size_t privsize) 975 { 976 return symbol__annotate(he->ms.sym, he->ms.map, privsize); 977 } 978 979 void hists__inc_nr_events(struct hists *self, u32 type) 980 { 981 ++self->stats.nr_events[0]; 982 ++self->stats.nr_events[type]; 983 } 984 985 size_t hists__fprintf_nr_events(struct hists *self, FILE *fp) 986 { 987 int i; 988 size_t ret = 0; 989 990 for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) { 991 const char *name; 992 993 if (self->stats.nr_events[i] == 0) 994 continue; 995 996 name = perf_event__name(i); 997 if (!strcmp(name, "UNKNOWN")) 998 continue; 999 1000 ret += fprintf(fp, "%16s events: %10d\n", name, 1001 self->stats.nr_events[i]); 1002 } 1003 1004 return ret; 1005 } 1006