projects/linux·blob master · refs

943 lines · 22.0 KiB

1// SPDX-License-Identifier: GPL-2.0
2#include <limits.h>
3#include <stdio.h>
4#include <stdlib.h>
5#include <linux/string.h>
6
7#include "../../util/callchain.h"
8#include "../../util/debug.h"
9#include "../../util/event.h"
10#include "../../util/hist.h"
11#include "../../util/map.h"
12#include "../../util/maps.h"
13#include "../../util/symbol.h"
14#include "../../util/sort.h"
15#include "../../util/evsel.h"
16#include "../../util/srcline.h"
17#include "../../util/string2.h"
18#include "../../util/thread.h"
19#include "../../util/block-info.h"
20#include <linux/ctype.h>
21#include <linux/zalloc.h>
22
23static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
24{
25 int i;
26 int ret = fprintf(fp, " ");
27
28 if (left_margin > USHRT_MAX)
29 left_margin = USHRT_MAX;
30
31 for (i = 0; i < left_margin; i++)
32 ret += fprintf(fp, " ");
33
34 return ret;
35}
36
37static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
38 int left_margin)
39{
40 int i;
41 size_t ret = callchain__fprintf_left_margin(fp, left_margin);
42
43 for (i = 0; i < depth; i++)
44 if (depth_mask & (1 << i))
45 ret += fprintf(fp, "| ");
46 else
47 ret += fprintf(fp, " ");
48
49 ret += fprintf(fp, "\n");
50
51 return ret;
52}
53
54static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_node *node,
55 struct callchain_list *chain,
56 int depth, int depth_mask, int period,
57 u64 total_samples, int left_margin)
58{
59 int i;
60 size_t ret = 0;
61 char bf[1024], *alloc_str = NULL;
62 char buf[64];
63 const char *str;
64
65 ret += callchain__fprintf_left_margin(fp, left_margin);
66 for (i = 0; i < depth; i++) {
67 if (depth_mask & (1 << i))
68 ret += fprintf(fp, "|");
69 else
70 ret += fprintf(fp, " ");
71 if (!period && i == depth - 1) {
72 ret += fprintf(fp, "--");
73 ret += callchain_node__fprintf_value(node, fp, total_samples);
74 ret += fprintf(fp, "--");
75 } else
76 ret += fprintf(fp, "%s", " ");
77 }
78
79 str = callchain_list__sym_name(chain, bf, sizeof(bf), false);
80
81 if (symbol_conf.show_branchflag_count) {
82 callchain_list_counts__printf_value(chain, NULL,
83 buf, sizeof(buf));
84
85 if (asprintf(&alloc_str, "%s%s", str, buf) < 0)
86 str = "Not enough memory!";
87 else
88 str = alloc_str;
89 }
90
91 fputs(str, fp);
92 fputc('\n', fp);
93 free(alloc_str);
94
95 return ret;
96}
97
98static struct symbol *rem_sq_bracket;
99static struct callchain_list rem_hits;
100
101static void init_rem_hits(void)
102{
103 rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
104 if (!rem_sq_bracket) {
105 fprintf(stderr, "Not enough memory to display remaining hits\n");
106 return;
107 }
108
109 strcpy(rem_sq_bracket->name, "[...]");
110 rem_hits.ms.sym = rem_sq_bracket;
111}
112
113static size_t __callchain__fprintf_graph(FILE *fp, struct rb_root *root,
114 u64 total_samples, int depth,
115 int depth_mask, int left_margin)
116{
117 struct rb_node *node, *next;
118 struct callchain_node *child = NULL;
119 struct callchain_list *chain;
120 int new_depth_mask = depth_mask;
121 u64 remaining;
122 size_t ret = 0;
123 int i;
124 uint entries_printed = 0;
125 int cumul_count = 0;
126
127 remaining = total_samples;
128
129 node = rb_first(root);
130 while (node) {
131 u64 new_total;
132 u64 cumul;
133
134 child = rb_entry(node, struct callchain_node, rb_node);
135 cumul = callchain_cumul_hits(child);
136 remaining -= cumul;
137 cumul_count += callchain_cumul_counts(child);
138
139 /*
140 * The depth mask manages the output of pipes that show
141 * the depth. We don't want to keep the pipes of the current
142 * level for the last child of this depth.
143 * Except if we have remaining filtered hits. They will
144 * supersede the last child
145 */
146 next = rb_next(node);
147 if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
148 new_depth_mask &= ~(1 << (depth - 1));
149
150 /*
151 * But we keep the older depth mask for the line separator
152 * to keep the level link until we reach the last child
153 */
154 ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
155 left_margin);
156 i = 0;
157 list_for_each_entry(chain, &child->val, list) {
158 ret += ipchain__fprintf_graph(fp, child, chain, depth,
159 new_depth_mask, i++,
160 total_samples,
161 left_margin);
162 }
163
164 if (callchain_param.mode == CHAIN_GRAPH_REL)
165 new_total = child->children_hit;
166 else
167 new_total = total_samples;
168
169 ret += __callchain__fprintf_graph(fp, &child->rb_root, new_total,
170 depth + 1,
171 new_depth_mask | (1 << depth),
172 left_margin);
173 node = next;
174 if (++entries_printed == callchain_param.print_limit)
175 break;
176 }
177
178 if (callchain_param.mode == CHAIN_GRAPH_REL &&
179 remaining && remaining != total_samples) {
180 struct callchain_node rem_node = {
181 .hit = remaining,
182 };
183
184 if (!rem_sq_bracket)
185 return ret;
186
187 if (callchain_param.value == CCVAL_COUNT && child && child->parent) {
188 rem_node.count = child->parent->children_count - cumul_count;
189 if (rem_node.count <= 0)
190 return ret;
191 }
192
193 new_depth_mask &= ~(1 << (depth - 1));
194 ret += ipchain__fprintf_graph(fp, &rem_node, &rem_hits, depth,
195 new_depth_mask, 0, total_samples,
196 left_margin);
197 }
198
199 return ret;
200}
201
202/*
203 * If have one single callchain root, don't bother printing
204 * its percentage (100 % in fractal mode and the same percentage
205 * than the hist in graph mode). This also avoid one level of column.
206 *
207 * However when percent-limit applied, it's possible that single callchain
208 * node have different (non-100% in fractal mode) percentage.
209 */
210static bool need_percent_display(struct rb_node *node, u64 parent_samples)
211{
212 struct callchain_node *cnode;
213
214 if (rb_next(node))
215 return true;
216
217 cnode = rb_entry(node, struct callchain_node, rb_node);
218 return callchain_cumul_hits(cnode) != parent_samples;
219}
220
221static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
222 u64 total_samples, u64 parent_samples,
223 int left_margin)
224{
225 struct callchain_node *cnode;
226 struct callchain_list *chain;
227 u32 entries_printed = 0;
228 bool printed = false;
229 struct rb_node *node;
230 int i = 0;
231 int ret = 0;
232 char bf[1024];
233
234 node = rb_first(root);
235 if (node && !need_percent_display(node, parent_samples)) {
236 cnode = rb_entry(node, struct callchain_node, rb_node);
237 list_for_each_entry(chain, &cnode->val, list) {
238 /*
239 * If we sort by symbol, the first entry is the same than
240 * the symbol. No need to print it otherwise it appears as
241 * displayed twice.
242 */
243 if (!i++ && field_order == NULL &&
244 sort_order && strstarts(sort_order, "sym"))
245 continue;
246
247 if (!printed) {
248 ret += callchain__fprintf_left_margin(fp, left_margin);
249 ret += fprintf(fp, "|\n");
250 ret += callchain__fprintf_left_margin(fp, left_margin);
251 ret += fprintf(fp, "---");
252 left_margin += 3;
253 printed = true;
254 } else
255 ret += callchain__fprintf_left_margin(fp, left_margin);
256
257 ret += fprintf(fp, "%s",
258 callchain_list__sym_name(chain, bf,
259 sizeof(bf),
260 false));
261
262 if (symbol_conf.show_branchflag_count)
263 ret += callchain_list_counts__printf_value(
264 chain, fp, NULL, 0);
265 ret += fprintf(fp, "\n");
266
267 if (++entries_printed == callchain_param.print_limit)
268 break;
269 }
270 root = &cnode->rb_root;
271 }
272
273 if (callchain_param.mode == CHAIN_GRAPH_REL)
274 total_samples = parent_samples;
275
276 ret += __callchain__fprintf_graph(fp, root, total_samples,
277 1, 1, left_margin);
278 if (ret) {
279 /* do not add a blank line if it printed nothing */
280 ret += fprintf(fp, "\n");
281 }
282
283 return ret;
284}
285
286static size_t __callchain__fprintf_flat(FILE *fp, struct callchain_node *node,
287 u64 total_samples)
288{
289 struct callchain_list *chain;
290 size_t ret = 0;
291 char bf[1024];
292
293 if (!node)
294 return 0;
295
296 ret += __callchain__fprintf_flat(fp, node->parent, total_samples);
297
298
299 list_for_each_entry(chain, &node->val, list) {
300 if (chain->ip >= PERF_CONTEXT_MAX)
301 continue;
302 ret += fprintf(fp, " %s\n", callchain_list__sym_name(chain,
303 bf, sizeof(bf), false));
304 }
305
306 return ret;
307}
308
309static size_t callchain__fprintf_flat(FILE *fp, struct rb_root *tree,
310 u64 total_samples)
311{
312 size_t ret = 0;
313 u32 entries_printed = 0;
314 struct callchain_node *chain;
315 struct rb_node *rb_node = rb_first(tree);
316
317 while (rb_node) {
318 chain = rb_entry(rb_node, struct callchain_node, rb_node);
319
320 ret += fprintf(fp, " ");
321 ret += callchain_node__fprintf_value(chain, fp, total_samples);
322 ret += fprintf(fp, "\n");
323 ret += __callchain__fprintf_flat(fp, chain, total_samples);
324 ret += fprintf(fp, "\n");
325 if (++entries_printed == callchain_param.print_limit)
326 break;
327
328 rb_node = rb_next(rb_node);
329 }
330
331 return ret;
332}
333
334static size_t __callchain__fprintf_folded(FILE *fp, struct callchain_node *node)
335{
336 const char *sep = symbol_conf.field_sep ?: ";";
337 struct callchain_list *chain;
338 size_t ret = 0;
339 char bf[1024];
340 bool first;
341
342 if (!node)
343 return 0;
344
345 ret += __callchain__fprintf_folded(fp, node->parent);
346
347 first = (ret == 0);
348 list_for_each_entry(chain, &node->val, list) {
349 if (chain->ip >= PERF_CONTEXT_MAX)
350 continue;
351 ret += fprintf(fp, "%s%s", first ? "" : sep,
352 callchain_list__sym_name(chain,
353 bf, sizeof(bf), false));
354 first = false;
355 }
356
357 return ret;
358}
359
360static size_t callchain__fprintf_folded(FILE *fp, struct rb_root *tree,
361 u64 total_samples)
362{
363 size_t ret = 0;
364 u32 entries_printed = 0;
365 struct callchain_node *chain;
366 struct rb_node *rb_node = rb_first(tree);
367
368 while (rb_node) {
369
370 chain = rb_entry(rb_node, struct callchain_node, rb_node);
371
372 ret += callchain_node__fprintf_value(chain, fp, total_samples);
373 ret += fprintf(fp, " ");
374 ret += __callchain__fprintf_folded(fp, chain);
375 ret += fprintf(fp, "\n");
376 if (++entries_printed == callchain_param.print_limit)
377 break;
378
379 rb_node = rb_next(rb_node);
380 }
381
382 return ret;
383}
384
385static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
386 u64 total_samples, int left_margin,
387 FILE *fp)
388{
389 u64 parent_samples = he->stat.period;
390
391 if (symbol_conf.cumulate_callchain)
392 parent_samples = he->stat_acc->period;
393
394 switch (callchain_param.mode) {
395 case CHAIN_GRAPH_REL:
396 return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
397 parent_samples, left_margin);
398 break;
399 case CHAIN_GRAPH_ABS:
400 return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
401 parent_samples, left_margin);
402 break;
403 case CHAIN_FLAT:
404 return callchain__fprintf_flat(fp, &he->sorted_chain, total_samples);
405 break;
406 case CHAIN_FOLDED:
407 return callchain__fprintf_folded(fp, &he->sorted_chain, total_samples);
408 break;
409 case CHAIN_NONE:
410 break;
411 default:
412 pr_err("Bad callchain mode\n");
413 }
414
415 return 0;
416}
417
418int __hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp,
419 struct perf_hpp_list *hpp_list)
420{
421 const char *sep = symbol_conf.field_sep;
422 struct perf_hpp_fmt *fmt;
423 char *start = hpp->buf;
424 int ret;
425 bool first = true;
426
427 if (symbol_conf.exclude_other && !he->parent)
428 return 0;
429
430 perf_hpp_list__for_each_format(hpp_list, fmt) {
431 if (perf_hpp__should_skip(fmt, he->hists))
432 continue;
433
434 /*
435 * If there's no field_sep, we still need
436 * to display initial ' '.
437 */
438 if (!sep || !first) {
439 ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: " ");
440 advance_hpp(hpp, ret);
441 } else
442 first = false;
443
444 if (perf_hpp__use_color() && fmt->color)
445 ret = fmt->color(fmt, hpp, he);
446 else
447 ret = fmt->entry(fmt, hpp, he);
448
449 ret = hist_entry__snprintf_alignment(he, hpp, fmt, ret);
450 advance_hpp(hpp, ret);
451 }
452
453 return hpp->buf - start;
454}
455
456static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
457{
458 return __hist_entry__snprintf(he, hpp, he->hists->hpp_list);
459}
460
461static int hist_entry__hierarchy_fprintf(struct hist_entry *he,
462 struct perf_hpp *hpp,
463 struct hists *hists,
464 FILE *fp)
465{
466 const char *sep = symbol_conf.field_sep;
467 struct perf_hpp_fmt *fmt;
468 struct perf_hpp_list_node *fmt_node;
469 char *buf = hpp->buf;
470 size_t size = hpp->size;
471 int ret, printed = 0;
472 bool first = true;
473
474 if (symbol_conf.exclude_other && !he->parent)
475 return 0;
476
477 ret = scnprintf(hpp->buf, hpp->size, "%*s", he->depth * HIERARCHY_INDENT, "");
478 advance_hpp(hpp, ret);
479
480 /* the first hpp_list_node is for overhead columns */
481 fmt_node = list_first_entry(&hists->hpp_formats,
482 struct perf_hpp_list_node, list);
483 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
484 /*
485 * If there's no field_sep, we still need
486 * to display initial ' '.
487 */
488 if (!sep || !first) {
489 ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: " ");
490 advance_hpp(hpp, ret);
491 } else
492 first = false;
493
494 if (perf_hpp__use_color() && fmt->color)
495 ret = fmt->color(fmt, hpp, he);
496 else
497 ret = fmt->entry(fmt, hpp, he);
498
499 ret = hist_entry__snprintf_alignment(he, hpp, fmt, ret);
500 advance_hpp(hpp, ret);
501 }
502
503 if (!sep)
504 ret = scnprintf(hpp->buf, hpp->size, "%*s",
505 (hists->nr_hpp_node - 2) * HIERARCHY_INDENT, "");
506 advance_hpp(hpp, ret);
507
508 printed += fprintf(fp, "%s", buf);
509
510 perf_hpp_list__for_each_format(he->hpp_list, fmt) {
511 hpp->buf = buf;
512 hpp->size = size;
513
514 /*
515 * No need to call hist_entry__snprintf_alignment() since this
516 * fmt is always the last column in the hierarchy mode.
517 */
518 if (perf_hpp__use_color() && fmt->color)
519 fmt->color(fmt, hpp, he);
520 else
521 fmt->entry(fmt, hpp, he);
522
523 /*
524 * dynamic entries are right-aligned but we want left-aligned
525 * in the hierarchy mode
526 */
527 printed += fprintf(fp, "%s%s", sep ?: " ", skip_spaces(buf));
528 }
529 printed += putc('\n', fp);
530
531 if (he->leaf && hist_entry__has_callchains(he) && symbol_conf.use_callchain) {
532 u64 total = hists__total_period(hists);
533
534 printed += hist_entry_callchain__fprintf(he, total, 0, fp);
535 goto out;
536 }
537
538out:
539 return printed;
540}
541
542static int hist_entry__block_fprintf(struct hist_entry *he,
543 char *bf, size_t size,
544 FILE *fp)
545{
546 struct block_hist *bh = container_of(he, struct block_hist, he);
547 int ret = 0;
548
549 for (unsigned int i = 0; i < bh->block_hists.nr_entries; i++) {
550 struct perf_hpp hpp = {
551 .buf = bf,
552 .size = size,
553 .skip = false,
554 };
555
556 bh->block_idx = i;
557 hist_entry__snprintf(he, &hpp);
558
559 if (!hpp.skip)
560 ret += fprintf(fp, "%s\n", bf);
561 }
562
563 return ret;
564}
565
566static int hist_entry__individual_block_fprintf(struct hist_entry *he,
567 char *bf, size_t size,
568 FILE *fp)
569{
570 int ret = 0;
571
572 struct perf_hpp hpp = {
573 .buf = bf,
574 .size = size,
575 .skip = false,
576 };
577
578 hist_entry__snprintf(he, &hpp);
579 if (!hpp.skip)
580 ret += fprintf(fp, "%s\n", bf);
581
582 return ret;
583}
584
585static int hist_entry__fprintf(struct hist_entry *he, size_t size,
586 char *bf, size_t bfsz, FILE *fp,
587 bool ignore_callchains)
588{
589 int ret;
590 int callchain_ret = 0;
591 struct perf_hpp hpp = {
592 .buf = bf,
593 .size = size,
594 };
595 struct hists *hists = he->hists;
596 u64 total_period = hists->stats.total_period;
597
598 if (size == 0 || size > bfsz)
599 size = hpp.size = bfsz;
600
601 if (symbol_conf.report_hierarchy)
602 return hist_entry__hierarchy_fprintf(he, &hpp, hists, fp);
603
604 if (symbol_conf.report_block)
605 return hist_entry__block_fprintf(he, bf, size, fp);
606
607 if (symbol_conf.report_individual_block)
608 return hist_entry__individual_block_fprintf(he, bf, size, fp);
609
610 hist_entry__snprintf(he, &hpp);
611
612 ret = fprintf(fp, "%s\n", bf);
613
614 if (hist_entry__has_callchains(he) && !ignore_callchains)
615 callchain_ret = hist_entry_callchain__fprintf(he, total_period,
616 0, fp);
617
618 ret += callchain_ret;
619
620 return ret;
621}
622
623static int print_hierarchy_indent(const char *sep, int indent,
624 const char *line, FILE *fp)
625{
626 int width;
627
628 if (sep != NULL || indent < 2)
629 return 0;
630
631 width = (indent - 2) * HIERARCHY_INDENT;
632
633 return fprintf(fp, "%-*.*s", width, width, line);
634}
635
636static int hists__fprintf_hierarchy_headers(struct hists *hists,
637 struct perf_hpp *hpp, FILE *fp)
638{
639 bool first_node, first_col;
640 int indent;
641 int depth;
642 unsigned width = 0;
643 unsigned header_width = 0;
644 struct perf_hpp_fmt *fmt;
645 struct perf_hpp_list_node *fmt_node;
646 struct perf_hpp_list *hpp_list = hists->hpp_list;
647 const char *sep = symbol_conf.field_sep;
648
649 indent = hists->nr_hpp_node;
650
651 /* the first hpp_list_node is for overhead columns */
652 fmt_node = list_first_entry(&hists->hpp_formats,
653 struct perf_hpp_list_node, list);
654
655 for (int line = 0; line < hpp_list->nr_header_lines; line++) {
656 /* first # is displayed one level up */
657 if (line)
658 fprintf(fp, "# ");
659
660 /* preserve max indent depth for column headers */
661 print_hierarchy_indent(sep, indent, " ", fp);
662
663 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
664 fmt->header(fmt, hpp, hists, line, NULL);
665 fprintf(fp, "%s%s", hpp->buf, sep ?: " ");
666 }
667
668 if (line < hpp_list->nr_header_lines - 1)
669 goto next_line;
670
671 /* combine sort headers with ' / ' */
672 first_node = true;
673 list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
674 if (!first_node)
675 header_width += fprintf(fp, " / ");
676 first_node = false;
677
678 first_col = true;
679 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
680 if (perf_hpp__should_skip(fmt, hists))
681 continue;
682
683 if (!first_col)
684 header_width += fprintf(fp, "+");
685 first_col = false;
686
687 fmt->header(fmt, hpp, hists, line, NULL);
688
689 header_width += fprintf(fp, "%s", strim(hpp->buf));
690 }
691 }
692
693next_line:
694 fprintf(fp, "\n");
695 }
696
697 fprintf(fp, "# ");
698
699 /* preserve max indent depth for initial dots */
700 print_hierarchy_indent(sep, indent, dots, fp);
701
702 /* the first hpp_list_node is for overhead columns */
703 fmt_node = list_first_entry(&hists->hpp_formats,
704 struct perf_hpp_list_node, list);
705
706 first_col = true;
707 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
708 if (!first_col)
709 fprintf(fp, "%s", sep ?: "..");
710 first_col = false;
711
712 width = fmt->width(fmt, hpp, hists);
713 fprintf(fp, "%.*s", width, dots);
714 }
715
716 depth = 0;
717 list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
718 first_col = true;
719 width = depth * HIERARCHY_INDENT;
720
721 perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
722 if (perf_hpp__should_skip(fmt, hists))
723 continue;
724
725 if (!first_col)
726 width++; /* for '+' sign between column header */
727 first_col = false;
728
729 width += fmt->width(fmt, hpp, hists);
730 }
731
732 if (width > header_width)
733 header_width = width;
734
735 depth++;
736 }
737
738 fprintf(fp, "%s%-.*s", sep ?: " ", header_width, dots);
739
740 fprintf(fp, "\n#\n");
741
742 return 2;
743}
744
745static void fprintf_line(struct hists *hists, struct perf_hpp *hpp,
746 int line, FILE *fp)
747{
748 struct perf_hpp_fmt *fmt;
749 const char *sep = symbol_conf.field_sep;
750 bool first = true;
751 int span = 0;
752
753 hists__for_each_format(hists, fmt) {
754 if (perf_hpp__should_skip(fmt, hists))
755 continue;
756
757 if (!first && !span)
758 fprintf(fp, "%s", sep ?: " ");
759 else
760 first = false;
761
762 fmt->header(fmt, hpp, hists, line, &span);
763
764 if (!span)
765 fprintf(fp, "%s", hpp->buf);
766 }
767}
768
769static int
770hists__fprintf_standard_headers(struct hists *hists,
771 struct perf_hpp *hpp,
772 FILE *fp)
773{
774 struct perf_hpp_list *hpp_list = hists->hpp_list;
775 struct perf_hpp_fmt *fmt;
776 unsigned int width;
777 const char *sep = symbol_conf.field_sep;
778 bool first = true;
779 int line;
780
781 for (line = 0; line < hpp_list->nr_header_lines; line++) {
782 /* first # is displayed one level up */
783 if (line)
784 fprintf(fp, "# ");
785 fprintf_line(hists, hpp, line, fp);
786 fprintf(fp, "\n");
787 }
788
789 if (sep)
790 return hpp_list->nr_header_lines;
791
792 first = true;
793
794 fprintf(fp, "# ");
795
796 hists__for_each_format(hists, fmt) {
797 unsigned int i;
798
799 if (perf_hpp__should_skip(fmt, hists))
800 continue;
801
802 if (!first)
803 fprintf(fp, "%s", sep ?: " ");
804 else
805 first = false;
806
807 width = fmt->width(fmt, hpp, hists);
808 for (i = 0; i < width; i++)
809 fprintf(fp, ".");
810 }
811
812 fprintf(fp, "\n");
813 fprintf(fp, "#\n");
814 return hpp_list->nr_header_lines + 2;
815}
816
817int hists__fprintf_headers(struct hists *hists, FILE *fp)
818{
819 char bf[1024];
820 struct perf_hpp dummy_hpp = {
821 .buf = bf,
822 .size = sizeof(bf),
823 };
824
825 fprintf(fp, "# ");
826
827 if (symbol_conf.report_hierarchy)
828 return hists__fprintf_hierarchy_headers(hists, &dummy_hpp, fp);
829 else
830 return hists__fprintf_standard_headers(hists, &dummy_hpp, fp);
831
832}
833
834size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
835 int max_cols, float min_pcnt, FILE *fp,
836 bool ignore_callchains)
837{
838 struct rb_node *nd;
839 size_t ret = 0;
840 const char *sep = symbol_conf.field_sep;
841 int nr_rows = 0;
842 size_t linesz;
843 char *line = NULL;
844 unsigned indent;
845
846 init_rem_hits();
847
848 hists__reset_column_width(hists);
849
850 if (symbol_conf.col_width_list_str)
851 perf_hpp__set_user_width(symbol_conf.col_width_list_str);
852
853 if (show_header)
854 nr_rows += hists__fprintf_headers(hists, fp);
855
856 if (max_rows && nr_rows >= max_rows)
857 goto out;
858
859 linesz = hists__sort_list_width(hists) + 3 + 1;
860 linesz += perf_hpp__color_overhead();
861 line = malloc(linesz);
862 if (line == NULL) {
863 ret = -1;
864 goto out;
865 }
866
867 indent = hists__overhead_width(hists) + 4;
868
869 for (nd = rb_first_cached(&hists->entries); nd;
870 nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD)) {
871 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
872 float percent;
873
874 if (h->filtered)
875 continue;
876
877 if (symbol_conf.report_individual_block)
878 percent = block_info__total_cycles_percent(h);
879 else
880 percent = hist_entry__get_percent_limit(h);
881
882 if (percent < min_pcnt)
883 continue;
884
885 ret += hist_entry__fprintf(h, max_cols, line, linesz, fp, ignore_callchains);
886
887 if (max_rows && ++nr_rows >= max_rows)
888 break;
889
890 /*
891 * If all children are filtered out or percent-limited,
892 * display "no entry >= x.xx%" message.
893 */
894 if (!h->leaf && !hist_entry__has_hierarchy_children(h, min_pcnt)) {
895 int depth = hists->nr_hpp_node + h->depth + 1;
896
897 print_hierarchy_indent(sep, depth, " ", fp);
898 fprintf(fp, "%*sno entry >= %.2f%%\n", indent, "", min_pcnt);
899
900 if (max_rows && ++nr_rows >= max_rows)
901 break;
902 }
903
904 if (h->ms.map == NULL && verbose > 1) {
905 maps__fprintf(thread__maps(h->thread), fp);
906 fprintf(fp, "%.10s end\n", graph_dotted_line);
907 }
908 }
909
910 free(line);
911out:
912 zfree(&rem_sq_bracket);
913
914 return ret;
915}
916
917size_t events_stats__fprintf(struct events_stats *stats, FILE *fp)
918{
919 int i;
920 size_t ret = 0;
921 u32 total = stats->nr_events[0];
922
923 for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
924 const char *name;
925
926 name = perf_event__name(i);
927 if (!strcmp(name, "UNKNOWN"))
928 continue;
929 if (symbol_conf.skip_empty && !stats->nr_events[i])
930 continue;
931
932 if (i && total) {
933 ret += fprintf(fp, "%20s events: %10d (%4.1f%%)\n",
934 name, stats->nr_events[i],
935 100.0 * stats->nr_events[i] / total);
936 } else {
937 ret += fprintf(fp, "%20s events: %10d\n",
938 name, stats->nr_events[i]);
939 }
940 }
941
942 return ret;
943}