2 #include "../libslang.h"
5 #include <linux/rbtree.h>
7 #include "../../util/evsel.h"
8 #include "../../util/evlist.h"
9 #include "../../util/hist.h"
10 #include "../../util/pstack.h"
11 #include "../../util/sort.h"
12 #include "../../util/util.h"
13 #include "../../arch/common.h"
15 #include "../browser.h"
16 #include "../helpline.h"
24 struct hist_entry
*he_selection
;
25 struct map_symbol
*selection
;
32 extern void hist_browser__init_hpp(void);
34 static int hists__browser_title(struct hists
*hists
, char *bf
, size_t size
,
37 static void hist_browser__refresh_dimensions(struct hist_browser
*browser
)
39 /* 3 == +/- toggle symbol before actual hist_entry rendering */
40 browser
->b
.width
= 3 + (hists__sort_list_width(browser
->hists
) +
44 static void hist_browser__reset(struct hist_browser
*browser
)
46 browser
->b
.nr_entries
= browser
->hists
->nr_entries
;
47 hist_browser__refresh_dimensions(browser
);
48 ui_browser__reset_index(&browser
->b
);
51 static char tree__folded_sign(bool unfolded
)
53 return unfolded
? '-' : '+';
56 static char map_symbol__folded(const struct map_symbol
*ms
)
58 return ms
->has_children
? tree__folded_sign(ms
->unfolded
) : ' ';
61 static char hist_entry__folded(const struct hist_entry
*he
)
63 return map_symbol__folded(&he
->ms
);
66 static char callchain_list__folded(const struct callchain_list
*cl
)
68 return map_symbol__folded(&cl
->ms
);
71 static void map_symbol__set_folding(struct map_symbol
*ms
, bool unfold
)
73 ms
->unfolded
= unfold
? ms
->has_children
: false;
76 static int callchain_node__count_rows_rb_tree(struct callchain_node
*node
)
81 for (nd
= rb_first(&node
->rb_root
); nd
; nd
= rb_next(nd
)) {
82 struct callchain_node
*child
= rb_entry(nd
, struct callchain_node
, rb_node
);
83 struct callchain_list
*chain
;
84 char folded_sign
= ' '; /* No children */
86 list_for_each_entry(chain
, &child
->val
, list
) {
88 /* We need this because we may not have children */
89 folded_sign
= callchain_list__folded(chain
);
90 if (folded_sign
== '+')
94 if (folded_sign
== '-') /* Have children and they're unfolded */
95 n
+= callchain_node__count_rows_rb_tree(child
);
101 static int callchain_node__count_rows(struct callchain_node
*node
)
103 struct callchain_list
*chain
;
104 bool unfolded
= false;
107 list_for_each_entry(chain
, &node
->val
, list
) {
109 unfolded
= chain
->ms
.unfolded
;
113 n
+= callchain_node__count_rows_rb_tree(node
);
118 static int callchain__count_rows(struct rb_root
*chain
)
123 for (nd
= rb_first(chain
); nd
; nd
= rb_next(nd
)) {
124 struct callchain_node
*node
= rb_entry(nd
, struct callchain_node
, rb_node
);
125 n
+= callchain_node__count_rows(node
);
131 static bool map_symbol__toggle_fold(struct map_symbol
*ms
)
136 if (!ms
->has_children
)
139 ms
->unfolded
= !ms
->unfolded
;
143 static void callchain_node__init_have_children_rb_tree(struct callchain_node
*node
)
145 struct rb_node
*nd
= rb_first(&node
->rb_root
);
147 for (nd
= rb_first(&node
->rb_root
); nd
; nd
= rb_next(nd
)) {
148 struct callchain_node
*child
= rb_entry(nd
, struct callchain_node
, rb_node
);
149 struct callchain_list
*chain
;
152 list_for_each_entry(chain
, &child
->val
, list
) {
155 chain
->ms
.has_children
= chain
->list
.next
!= &child
->val
||
156 !RB_EMPTY_ROOT(&child
->rb_root
);
158 chain
->ms
.has_children
= chain
->list
.next
== &child
->val
&&
159 !RB_EMPTY_ROOT(&child
->rb_root
);
162 callchain_node__init_have_children_rb_tree(child
);
166 static void callchain_node__init_have_children(struct callchain_node
*node
)
168 struct callchain_list
*chain
;
170 list_for_each_entry(chain
, &node
->val
, list
)
171 chain
->ms
.has_children
= !RB_EMPTY_ROOT(&node
->rb_root
);
173 callchain_node__init_have_children_rb_tree(node
);
176 static void callchain__init_have_children(struct rb_root
*root
)
180 for (nd
= rb_first(root
); nd
; nd
= rb_next(nd
)) {
181 struct callchain_node
*node
= rb_entry(nd
, struct callchain_node
, rb_node
);
182 callchain_node__init_have_children(node
);
186 static void hist_entry__init_have_children(struct hist_entry
*he
)
188 if (!he
->init_have_children
) {
189 he
->ms
.has_children
= !RB_EMPTY_ROOT(&he
->sorted_chain
);
190 callchain__init_have_children(&he
->sorted_chain
);
191 he
->init_have_children
= true;
195 static bool hist_browser__toggle_fold(struct hist_browser
*browser
)
197 if (map_symbol__toggle_fold(browser
->selection
)) {
198 struct hist_entry
*he
= browser
->he_selection
;
200 hist_entry__init_have_children(he
);
201 browser
->hists
->nr_entries
-= he
->nr_rows
;
204 he
->nr_rows
= callchain__count_rows(&he
->sorted_chain
);
207 browser
->hists
->nr_entries
+= he
->nr_rows
;
208 browser
->b
.nr_entries
= browser
->hists
->nr_entries
;
213 /* If it doesn't have children, no toggling performed */
217 static int callchain_node__set_folding_rb_tree(struct callchain_node
*node
, bool unfold
)
222 for (nd
= rb_first(&node
->rb_root
); nd
; nd
= rb_next(nd
)) {
223 struct callchain_node
*child
= rb_entry(nd
, struct callchain_node
, rb_node
);
224 struct callchain_list
*chain
;
225 bool has_children
= false;
227 list_for_each_entry(chain
, &child
->val
, list
) {
229 map_symbol__set_folding(&chain
->ms
, unfold
);
230 has_children
= chain
->ms
.has_children
;
234 n
+= callchain_node__set_folding_rb_tree(child
, unfold
);
240 static int callchain_node__set_folding(struct callchain_node
*node
, bool unfold
)
242 struct callchain_list
*chain
;
243 bool has_children
= false;
246 list_for_each_entry(chain
, &node
->val
, list
) {
248 map_symbol__set_folding(&chain
->ms
, unfold
);
249 has_children
= chain
->ms
.has_children
;
253 n
+= callchain_node__set_folding_rb_tree(node
, unfold
);
258 static int callchain__set_folding(struct rb_root
*chain
, bool unfold
)
263 for (nd
= rb_first(chain
); nd
; nd
= rb_next(nd
)) {
264 struct callchain_node
*node
= rb_entry(nd
, struct callchain_node
, rb_node
);
265 n
+= callchain_node__set_folding(node
, unfold
);
271 static void hist_entry__set_folding(struct hist_entry
*he
, bool unfold
)
273 hist_entry__init_have_children(he
);
274 map_symbol__set_folding(&he
->ms
, unfold
);
276 if (he
->ms
.has_children
) {
277 int n
= callchain__set_folding(&he
->sorted_chain
, unfold
);
278 he
->nr_rows
= unfold
? n
: 0;
283 static void hists__set_folding(struct hists
*hists
, bool unfold
)
287 hists
->nr_entries
= 0;
289 for (nd
= rb_first(&hists
->entries
); nd
; nd
= rb_next(nd
)) {
290 struct hist_entry
*he
= rb_entry(nd
, struct hist_entry
, rb_node
);
291 hist_entry__set_folding(he
, unfold
);
292 hists
->nr_entries
+= 1 + he
->nr_rows
;
296 static void hist_browser__set_folding(struct hist_browser
*browser
, bool unfold
)
298 hists__set_folding(browser
->hists
, unfold
);
299 browser
->b
.nr_entries
= browser
->hists
->nr_entries
;
300 /* Go to the start, we may be way after valid entries after a collapse */
301 ui_browser__reset_index(&browser
->b
);
304 static void ui_browser__warn_lost_events(struct ui_browser
*browser
)
306 ui_browser__warning(browser
, 4,
307 "Events are being lost, check IO/CPU overload!\n\n"
308 "You may want to run 'perf' using a RT scheduler policy:\n\n"
309 " perf top -r 80\n\n"
310 "Or reduce the sampling frequency.");
313 static void hist_browser__update_pcnt_entries(struct hist_browser
*hb
);
315 static int hist_browser__run(struct hist_browser
*browser
, const char *ev_name
,
316 struct hist_browser_timer
*hbt
)
320 int delay_secs
= hbt
? hbt
->refresh
: 0;
322 browser
->b
.entries
= &browser
->hists
->entries
;
323 browser
->b
.nr_entries
= browser
->hists
->nr_entries
;
324 if (browser
->min_pcnt
)
325 browser
->b
.nr_entries
= browser
->nr_pcnt_entries
;
327 hist_browser__refresh_dimensions(browser
);
328 hists__browser_title(browser
->hists
, title
, sizeof(title
), ev_name
);
330 if (ui_browser__show(&browser
->b
, title
,
331 "Press '?' for help on key bindings") < 0)
335 key
= ui_browser__run(&browser
->b
, delay_secs
);
340 hbt
->timer(hbt
->arg
);
342 if (browser
->min_pcnt
) {
343 hist_browser__update_pcnt_entries(browser
);
344 nr_entries
= browser
->nr_pcnt_entries
;
346 nr_entries
= browser
->hists
->nr_entries
;
349 ui_browser__update_nr_entries(&browser
->b
, nr_entries
);
351 if (browser
->hists
->stats
.nr_lost_warned
!=
352 browser
->hists
->stats
.nr_events
[PERF_RECORD_LOST
]) {
353 browser
->hists
->stats
.nr_lost_warned
=
354 browser
->hists
->stats
.nr_events
[PERF_RECORD_LOST
];
355 ui_browser__warn_lost_events(&browser
->b
);
358 hists__browser_title(browser
->hists
, title
, sizeof(title
), ev_name
);
359 ui_browser__show_title(&browser
->b
, title
);
362 case 'D': { /* Debug */
364 struct hist_entry
*h
= rb_entry(browser
->b
.top
,
365 struct hist_entry
, rb_node
);
367 ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
368 seq
++, browser
->b
.nr_entries
,
369 browser
->hists
->nr_entries
,
373 h
->row_offset
, h
->nr_rows
);
377 /* Collapse the whole world. */
378 hist_browser__set_folding(browser
, false);
381 /* Expand the whole world. */
382 hist_browser__set_folding(browser
, true);
385 if (hist_browser__toggle_fold(browser
))
393 ui_browser__hide(&browser
->b
);
397 static char *callchain_list__sym_name(struct callchain_list
*cl
,
398 char *bf
, size_t bfsize
, bool show_dso
)
403 printed
= scnprintf(bf
, bfsize
, "%s", cl
->ms
.sym
->name
);
405 printed
= scnprintf(bf
, bfsize
, "%#" PRIx64
, cl
->ip
);
408 scnprintf(bf
+ printed
, bfsize
- printed
, " %s",
409 cl
->ms
.map
? cl
->ms
.map
->dso
->short_name
: "unknown");
414 #define LEVEL_OFFSET_STEP 3
416 static int hist_browser__show_callchain_node_rb_tree(struct hist_browser
*browser
,
417 struct callchain_node
*chain_node
,
418 u64 total
, int level
,
421 bool *is_current_entry
)
423 struct rb_node
*node
;
424 int first_row
= row
, width
, offset
= level
* LEVEL_OFFSET_STEP
;
425 u64 new_total
, remaining
;
427 if (callchain_param
.mode
== CHAIN_GRAPH_REL
)
428 new_total
= chain_node
->children_hit
;
432 remaining
= new_total
;
433 node
= rb_first(&chain_node
->rb_root
);
435 struct callchain_node
*child
= rb_entry(node
, struct callchain_node
, rb_node
);
436 struct rb_node
*next
= rb_next(node
);
437 u64 cumul
= callchain_cumul_hits(child
);
438 struct callchain_list
*chain
;
439 char folded_sign
= ' ';
441 int extra_offset
= 0;
445 list_for_each_entry(chain
, &child
->val
, list
) {
446 char bf
[1024], *alloc_str
;
449 bool was_first
= first
;
454 extra_offset
= LEVEL_OFFSET_STEP
;
456 folded_sign
= callchain_list__folded(chain
);
457 if (*row_offset
!= 0) {
463 str
= callchain_list__sym_name(chain
, bf
, sizeof(bf
),
466 double percent
= cumul
* 100.0 / new_total
;
468 if (asprintf(&alloc_str
, "%2.2f%% %s", percent
, str
) < 0)
469 str
= "Not enough memory!";
474 color
= HE_COLORSET_NORMAL
;
475 width
= browser
->b
.width
- (offset
+ extra_offset
+ 2);
476 if (ui_browser__is_current_entry(&browser
->b
, row
)) {
477 browser
->selection
= &chain
->ms
;
478 color
= HE_COLORSET_SELECTED
;
479 *is_current_entry
= true;
482 ui_browser__set_color(&browser
->b
, color
);
483 ui_browser__gotorc(&browser
->b
, row
, 0);
484 slsmg_write_nstring(" ", offset
+ extra_offset
);
485 slsmg_printf("%c ", folded_sign
);
486 slsmg_write_nstring(str
, width
);
489 if (++row
== browser
->b
.height
)
492 if (folded_sign
== '+')
496 if (folded_sign
== '-') {
497 const int new_level
= level
+ (extra_offset
? 2 : 1);
498 row
+= hist_browser__show_callchain_node_rb_tree(browser
, child
, new_total
,
499 new_level
, row
, row_offset
,
502 if (row
== browser
->b
.height
)
507 return row
- first_row
;
510 static int hist_browser__show_callchain_node(struct hist_browser
*browser
,
511 struct callchain_node
*node
,
512 int level
, unsigned short row
,
514 bool *is_current_entry
)
516 struct callchain_list
*chain
;
518 offset
= level
* LEVEL_OFFSET_STEP
,
519 width
= browser
->b
.width
- offset
;
520 char folded_sign
= ' ';
522 list_for_each_entry(chain
, &node
->val
, list
) {
526 folded_sign
= callchain_list__folded(chain
);
528 if (*row_offset
!= 0) {
533 color
= HE_COLORSET_NORMAL
;
534 if (ui_browser__is_current_entry(&browser
->b
, row
)) {
535 browser
->selection
= &chain
->ms
;
536 color
= HE_COLORSET_SELECTED
;
537 *is_current_entry
= true;
540 s
= callchain_list__sym_name(chain
, bf
, sizeof(bf
),
542 ui_browser__gotorc(&browser
->b
, row
, 0);
543 ui_browser__set_color(&browser
->b
, color
);
544 slsmg_write_nstring(" ", offset
);
545 slsmg_printf("%c ", folded_sign
);
546 slsmg_write_nstring(s
, width
- 2);
548 if (++row
== browser
->b
.height
)
552 if (folded_sign
== '-')
553 row
+= hist_browser__show_callchain_node_rb_tree(browser
, node
,
554 browser
->hists
->stats
.total_period
,
559 return row
- first_row
;
562 static int hist_browser__show_callchain(struct hist_browser
*browser
,
563 struct rb_root
*chain
,
564 int level
, unsigned short row
,
566 bool *is_current_entry
)
571 for (nd
= rb_first(chain
); nd
; nd
= rb_next(nd
)) {
572 struct callchain_node
*node
= rb_entry(nd
, struct callchain_node
, rb_node
);
574 row
+= hist_browser__show_callchain_node(browser
, node
, level
,
577 if (row
== browser
->b
.height
)
581 return row
- first_row
;
585 struct ui_browser
*b
;
590 static int __hpp__overhead_callback(struct perf_hpp
*hpp
, bool front
)
592 struct hpp_arg
*arg
= hpp
->ptr
;
594 if (arg
->current_entry
&& arg
->b
->navkeypressed
)
595 ui_browser__set_color(arg
->b
, HE_COLORSET_SELECTED
);
597 ui_browser__set_color(arg
->b
, HE_COLORSET_NORMAL
);
600 if (!symbol_conf
.use_callchain
)
603 slsmg_printf("%c ", arg
->folded_sign
);
610 static int __hpp__color_callback(struct perf_hpp
*hpp
, bool front __maybe_unused
)
612 struct hpp_arg
*arg
= hpp
->ptr
;
614 if (!arg
->current_entry
|| !arg
->b
->navkeypressed
)
615 ui_browser__set_color(arg
->b
, HE_COLORSET_NORMAL
);
619 static int __hpp__slsmg_color_printf(struct perf_hpp
*hpp
, const char *fmt
, ...)
621 struct hpp_arg
*arg
= hpp
->ptr
;
627 percent
= va_arg(args
, double);
630 ui_browser__set_percent_color(arg
->b
, percent
, arg
->current_entry
);
632 ret
= scnprintf(hpp
->buf
, hpp
->size
, fmt
, percent
);
633 slsmg_printf("%s", hpp
->buf
);
635 advance_hpp(hpp
, ret
);
639 #define __HPP_COLOR_PERCENT_FN(_type, _field, _cb) \
640 static u64 __hpp_get_##_field(struct hist_entry *he) \
642 return he->stat._field; \
646 hist_browser__hpp_color_##_type(struct perf_hpp_fmt *fmt __maybe_unused,\
647 struct perf_hpp *hpp, \
648 struct hist_entry *he) \
650 return __hpp__fmt(hpp, he, __hpp_get_##_field, _cb, " %6.2f%%", \
651 __hpp__slsmg_color_printf, true); \
654 __HPP_COLOR_PERCENT_FN(overhead
, period
, __hpp__overhead_callback
)
655 __HPP_COLOR_PERCENT_FN(overhead_sys
, period_sys
, __hpp__color_callback
)
656 __HPP_COLOR_PERCENT_FN(overhead_us
, period_us
, __hpp__color_callback
)
657 __HPP_COLOR_PERCENT_FN(overhead_guest_sys
, period_guest_sys
, __hpp__color_callback
)
658 __HPP_COLOR_PERCENT_FN(overhead_guest_us
, period_guest_us
, __hpp__color_callback
)
660 #undef __HPP_COLOR_PERCENT_FN
662 void hist_browser__init_hpp(void)
666 perf_hpp__format
[PERF_HPP__OVERHEAD
].color
=
667 hist_browser__hpp_color_overhead
;
668 perf_hpp__format
[PERF_HPP__OVERHEAD_SYS
].color
=
669 hist_browser__hpp_color_overhead_sys
;
670 perf_hpp__format
[PERF_HPP__OVERHEAD_US
].color
=
671 hist_browser__hpp_color_overhead_us
;
672 perf_hpp__format
[PERF_HPP__OVERHEAD_GUEST_SYS
].color
=
673 hist_browser__hpp_color_overhead_guest_sys
;
674 perf_hpp__format
[PERF_HPP__OVERHEAD_GUEST_US
].color
=
675 hist_browser__hpp_color_overhead_guest_us
;
678 static int hist_browser__show_entry(struct hist_browser
*browser
,
679 struct hist_entry
*entry
,
684 int width
= browser
->b
.width
;
685 char folded_sign
= ' ';
686 bool current_entry
= ui_browser__is_current_entry(&browser
->b
, row
);
687 off_t row_offset
= entry
->row_offset
;
689 struct perf_hpp_fmt
*fmt
;
692 browser
->he_selection
= entry
;
693 browser
->selection
= &entry
->ms
;
696 if (symbol_conf
.use_callchain
) {
697 hist_entry__init_have_children(entry
);
698 folded_sign
= hist_entry__folded(entry
);
701 if (row_offset
== 0) {
702 struct hpp_arg arg
= {
704 .folded_sign
= folded_sign
,
705 .current_entry
= current_entry
,
707 struct perf_hpp hpp
= {
713 ui_browser__gotorc(&browser
->b
, row
, 0);
715 perf_hpp__for_each_format(fmt
) {
723 width
-= fmt
->color(fmt
, &hpp
, entry
);
725 width
-= fmt
->entry(fmt
, &hpp
, entry
);
726 slsmg_printf("%s", s
);
730 /* The scroll bar isn't being used */
731 if (!browser
->b
.navkeypressed
)
734 hist_entry__sort_snprintf(entry
, s
, sizeof(s
), browser
->hists
);
735 slsmg_write_nstring(s
, width
);
741 if (folded_sign
== '-' && row
!= browser
->b
.height
) {
742 printed
+= hist_browser__show_callchain(browser
, &entry
->sorted_chain
,
746 browser
->he_selection
= entry
;
752 static void ui_browser__hists_init_top(struct ui_browser
*browser
)
754 if (browser
->top
== NULL
) {
755 struct hist_browser
*hb
;
757 hb
= container_of(browser
, struct hist_browser
, b
);
758 browser
->top
= rb_first(&hb
->hists
->entries
);
762 static unsigned int hist_browser__refresh(struct ui_browser
*browser
)
766 struct hist_browser
*hb
= container_of(browser
, struct hist_browser
, b
);
768 ui_browser__hists_init_top(browser
);
770 for (nd
= browser
->top
; nd
; nd
= rb_next(nd
)) {
771 struct hist_entry
*h
= rb_entry(nd
, struct hist_entry
, rb_node
);
772 float percent
= h
->stat
.period
* 100.0 /
773 hb
->hists
->stats
.total_period
;
778 if (percent
< hb
->min_pcnt
)
781 row
+= hist_browser__show_entry(hb
, h
, row
);
782 if (row
== browser
->height
)
789 static struct rb_node
*hists__filter_entries(struct rb_node
*nd
,
794 struct hist_entry
*h
= rb_entry(nd
, struct hist_entry
, rb_node
);
795 float percent
= h
->stat
.period
* 100.0 /
796 hists
->stats
.total_period
;
798 if (percent
< min_pcnt
)
810 static struct rb_node
*hists__filter_prev_entries(struct rb_node
*nd
,
815 struct hist_entry
*h
= rb_entry(nd
, struct hist_entry
, rb_node
);
816 float percent
= h
->stat
.period
* 100.0 /
817 hists
->stats
.total_period
;
819 if (!h
->filtered
&& percent
>= min_pcnt
)
828 static void ui_browser__hists_seek(struct ui_browser
*browser
,
829 off_t offset
, int whence
)
831 struct hist_entry
*h
;
834 struct hist_browser
*hb
;
836 hb
= container_of(browser
, struct hist_browser
, b
);
838 if (browser
->nr_entries
== 0)
841 ui_browser__hists_init_top(browser
);
845 nd
= hists__filter_entries(rb_first(browser
->entries
),
846 hb
->hists
, hb
->min_pcnt
);
852 nd
= hists__filter_prev_entries(rb_last(browser
->entries
),
853 hb
->hists
, hb
->min_pcnt
);
861 * Moves not relative to the first visible entry invalidates its
864 h
= rb_entry(browser
->top
, struct hist_entry
, rb_node
);
868 * Here we have to check if nd is expanded (+), if it is we can't go
869 * the next top level hist_entry, instead we must compute an offset of
870 * what _not_ to show and not change the first visible entry.
872 * This offset increments when we are going from top to bottom and
873 * decreases when we're going from bottom to top.
875 * As we don't have backpointers to the top level in the callchains
876 * structure, we need to always print the whole hist_entry callchain,
877 * skipping the first ones that are before the first visible entry
878 * and stop when we printed enough lines to fill the screen.
883 h
= rb_entry(nd
, struct hist_entry
, rb_node
);
884 if (h
->ms
.unfolded
) {
885 u16 remaining
= h
->nr_rows
- h
->row_offset
;
886 if (offset
> remaining
) {
890 h
->row_offset
+= offset
;
896 nd
= hists__filter_entries(rb_next(nd
), hb
->hists
,
902 } while (offset
!= 0);
903 } else if (offset
< 0) {
905 h
= rb_entry(nd
, struct hist_entry
, rb_node
);
906 if (h
->ms
.unfolded
) {
908 if (-offset
> h
->row_offset
) {
909 offset
+= h
->row_offset
;
912 h
->row_offset
+= offset
;
918 if (-offset
> h
->nr_rows
) {
919 offset
+= h
->nr_rows
;
922 h
->row_offset
= h
->nr_rows
+ offset
;
930 nd
= hists__filter_prev_entries(rb_prev(nd
), hb
->hists
,
938 * Last unfiltered hist_entry, check if it is
939 * unfolded, if it is then we should have
940 * row_offset at its last entry.
942 h
= rb_entry(nd
, struct hist_entry
, rb_node
);
944 h
->row_offset
= h
->nr_rows
;
951 h
= rb_entry(nd
, struct hist_entry
, rb_node
);
956 static int hist_browser__fprintf_callchain_node_rb_tree(struct hist_browser
*browser
,
957 struct callchain_node
*chain_node
,
958 u64 total
, int level
,
961 struct rb_node
*node
;
962 int offset
= level
* LEVEL_OFFSET_STEP
;
963 u64 new_total
, remaining
;
966 if (callchain_param
.mode
== CHAIN_GRAPH_REL
)
967 new_total
= chain_node
->children_hit
;
971 remaining
= new_total
;
972 node
= rb_first(&chain_node
->rb_root
);
974 struct callchain_node
*child
= rb_entry(node
, struct callchain_node
, rb_node
);
975 struct rb_node
*next
= rb_next(node
);
976 u64 cumul
= callchain_cumul_hits(child
);
977 struct callchain_list
*chain
;
978 char folded_sign
= ' ';
980 int extra_offset
= 0;
984 list_for_each_entry(chain
, &child
->val
, list
) {
985 char bf
[1024], *alloc_str
;
987 bool was_first
= first
;
992 extra_offset
= LEVEL_OFFSET_STEP
;
994 folded_sign
= callchain_list__folded(chain
);
997 str
= callchain_list__sym_name(chain
, bf
, sizeof(bf
),
1000 double percent
= cumul
* 100.0 / new_total
;
1002 if (asprintf(&alloc_str
, "%2.2f%% %s", percent
, str
) < 0)
1003 str
= "Not enough memory!";
1008 printed
+= fprintf(fp
, "%*s%c %s\n", offset
+ extra_offset
, " ", folded_sign
, str
);
1010 if (folded_sign
== '+')
1014 if (folded_sign
== '-') {
1015 const int new_level
= level
+ (extra_offset
? 2 : 1);
1016 printed
+= hist_browser__fprintf_callchain_node_rb_tree(browser
, child
, new_total
,
1026 static int hist_browser__fprintf_callchain_node(struct hist_browser
*browser
,
1027 struct callchain_node
*node
,
1028 int level
, FILE *fp
)
1030 struct callchain_list
*chain
;
1031 int offset
= level
* LEVEL_OFFSET_STEP
;
1032 char folded_sign
= ' ';
1035 list_for_each_entry(chain
, &node
->val
, list
) {
1038 folded_sign
= callchain_list__folded(chain
);
1039 s
= callchain_list__sym_name(chain
, bf
, sizeof(bf
), browser
->show_dso
);
1040 printed
+= fprintf(fp
, "%*s%c %s\n", offset
, " ", folded_sign
, s
);
1043 if (folded_sign
== '-')
1044 printed
+= hist_browser__fprintf_callchain_node_rb_tree(browser
, node
,
1045 browser
->hists
->stats
.total_period
,
1050 static int hist_browser__fprintf_callchain(struct hist_browser
*browser
,
1051 struct rb_root
*chain
, int level
, FILE *fp
)
1056 for (nd
= rb_first(chain
); nd
; nd
= rb_next(nd
)) {
1057 struct callchain_node
*node
= rb_entry(nd
, struct callchain_node
, rb_node
);
1059 printed
+= hist_browser__fprintf_callchain_node(browser
, node
, level
, fp
);
1065 static int hist_browser__fprintf_entry(struct hist_browser
*browser
,
1066 struct hist_entry
*he
, FILE *fp
)
1071 char folded_sign
= ' ';
1073 if (symbol_conf
.use_callchain
)
1074 folded_sign
= hist_entry__folded(he
);
1076 hist_entry__sort_snprintf(he
, s
, sizeof(s
), browser
->hists
);
1077 percent
= (he
->stat
.period
* 100.0) / browser
->hists
->stats
.total_period
;
1079 if (symbol_conf
.use_callchain
)
1080 printed
+= fprintf(fp
, "%c ", folded_sign
);
1082 printed
+= fprintf(fp
, " %5.2f%%", percent
);
1084 if (symbol_conf
.show_nr_samples
)
1085 printed
+= fprintf(fp
, " %11u", he
->stat
.nr_events
);
1087 if (symbol_conf
.show_total_period
)
1088 printed
+= fprintf(fp
, " %12" PRIu64
, he
->stat
.period
);
1090 printed
+= fprintf(fp
, "%s\n", rtrim(s
));
1092 if (folded_sign
== '-')
1093 printed
+= hist_browser__fprintf_callchain(browser
, &he
->sorted_chain
, 1, fp
);
1098 static int hist_browser__fprintf(struct hist_browser
*browser
, FILE *fp
)
1100 struct rb_node
*nd
= hists__filter_entries(rb_first(browser
->b
.entries
),
1106 struct hist_entry
*h
= rb_entry(nd
, struct hist_entry
, rb_node
);
1108 printed
+= hist_browser__fprintf_entry(browser
, h
, fp
);
1109 nd
= hists__filter_entries(rb_next(nd
), browser
->hists
,
1116 static int hist_browser__dump(struct hist_browser
*browser
)
1122 scnprintf(filename
, sizeof(filename
), "perf.hist.%d", browser
->print_seq
);
1123 if (access(filename
, F_OK
))
1126 * XXX: Just an arbitrary lazy upper limit
1128 if (++browser
->print_seq
== 8192) {
1129 ui_helpline__fpush("Too many perf.hist.N files, nothing written!");
1134 fp
= fopen(filename
, "w");
1137 const char *err
= strerror_r(errno
, bf
, sizeof(bf
));
1138 ui_helpline__fpush("Couldn't write to %s: %s", filename
, err
);
1142 ++browser
->print_seq
;
1143 hist_browser__fprintf(browser
, fp
);
1145 ui_helpline__fpush("%s written!", filename
);
1150 static struct hist_browser
*hist_browser__new(struct hists
*hists
)
1152 struct hist_browser
*browser
= zalloc(sizeof(*browser
));
1155 browser
->hists
= hists
;
1156 browser
->b
.refresh
= hist_browser__refresh
;
1157 browser
->b
.seek
= ui_browser__hists_seek
;
1158 browser
->b
.use_navkeypressed
= true;
1164 static void hist_browser__delete(struct hist_browser
*browser
)
1169 static struct hist_entry
*hist_browser__selected_entry(struct hist_browser
*browser
)
1171 return browser
->he_selection
;
1174 static struct thread
*hist_browser__selected_thread(struct hist_browser
*browser
)
1176 return browser
->he_selection
->thread
;
1179 static int hists__browser_title(struct hists
*hists
, char *bf
, size_t size
,
1180 const char *ev_name
)
1184 const struct dso
*dso
= hists
->dso_filter
;
1185 const struct thread
*thread
= hists
->thread_filter
;
1186 unsigned long nr_samples
= hists
->stats
.nr_events
[PERF_RECORD_SAMPLE
];
1187 u64 nr_events
= hists
->stats
.total_period
;
1188 struct perf_evsel
*evsel
= hists_to_evsel(hists
);
1190 size_t buflen
= sizeof(buf
);
1192 if (perf_evsel__is_group_event(evsel
)) {
1193 struct perf_evsel
*pos
;
1195 perf_evsel__group_desc(evsel
, buf
, buflen
);
1198 for_each_group_member(pos
, evsel
) {
1199 nr_samples
+= pos
->hists
.stats
.nr_events
[PERF_RECORD_SAMPLE
];
1200 nr_events
+= pos
->hists
.stats
.total_period
;
1204 nr_samples
= convert_unit(nr_samples
, &unit
);
1205 printed
= scnprintf(bf
, size
,
1206 "Samples: %lu%c of event '%s', Event count (approx.): %lu",
1207 nr_samples
, unit
, ev_name
, nr_events
);
1210 if (hists
->uid_filter_str
)
1211 printed
+= snprintf(bf
+ printed
, size
- printed
,
1212 ", UID: %s", hists
->uid_filter_str
);
1214 printed
+= scnprintf(bf
+ printed
, size
- printed
,
1216 (thread
->comm_set
? thread__comm_str(thread
) : ""),
1219 printed
+= scnprintf(bf
+ printed
, size
- printed
,
1220 ", DSO: %s", dso
->short_name
);
1224 static inline void free_popup_options(char **options
, int n
)
1228 for (i
= 0; i
< n
; ++i
)
1232 /* Check whether the browser is for 'top' or 'report' */
1233 static inline bool is_report_browser(void *timer
)
1235 return timer
== NULL
;
1239 * Only runtime switching of perf data file will make "input_name" point
1240 * to a malloced buffer. So add "is_input_name_malloced" flag to decide
1241 * whether we need to call free() for current "input_name" during the switch.
1243 static bool is_input_name_malloced
= false;
1245 static int switch_data_file(void)
1247 char *pwd
, *options
[32], *abs_path
[32], *tmp
;
1249 int nr_options
= 0, choice
= -1, ret
= -1;
1250 struct dirent
*dent
;
1252 pwd
= getenv("PWD");
1256 pwd_dir
= opendir(pwd
);
1260 memset(options
, 0, sizeof(options
));
1261 memset(options
, 0, sizeof(abs_path
));
1263 while ((dent
= readdir(pwd_dir
))) {
1264 char path
[PATH_MAX
];
1266 char *name
= dent
->d_name
;
1269 if (!(dent
->d_type
== DT_REG
))
1272 snprintf(path
, sizeof(path
), "%s/%s", pwd
, name
);
1274 file
= fopen(path
, "r");
1278 if (fread(&magic
, 1, 8, file
) < 8)
1279 goto close_file_and_continue
;
1281 if (is_perf_magic(magic
)) {
1282 options
[nr_options
] = strdup(name
);
1283 if (!options
[nr_options
])
1284 goto close_file_and_continue
;
1286 abs_path
[nr_options
] = strdup(path
);
1287 if (!abs_path
[nr_options
]) {
1288 zfree(&options
[nr_options
]);
1289 ui__warning("Can't search all data files due to memory shortage.\n");
1297 close_file_and_continue
:
1299 if (nr_options
>= 32) {
1300 ui__warning("Too many perf data files in PWD!\n"
1301 "Only the first 32 files will be listed.\n");
1308 choice
= ui__popup_menu(nr_options
, options
);
1309 if (choice
< nr_options
&& choice
>= 0) {
1310 tmp
= strdup(abs_path
[choice
]);
1312 if (is_input_name_malloced
)
1313 free((void *)input_name
);
1315 is_input_name_malloced
= true;
1318 ui__warning("Data switch failed due to memory shortage!\n");
1322 free_popup_options(options
, nr_options
);
1323 free_popup_options(abs_path
, nr_options
);
1327 static void hist_browser__update_pcnt_entries(struct hist_browser
*hb
)
1330 struct rb_node
*nd
= rb_first(&hb
->hists
->entries
);
1334 nd
= hists__filter_entries(rb_next(nd
), hb
->hists
,
1338 hb
->nr_pcnt_entries
= nr_entries
;
1341 static int perf_evsel__hists_browse(struct perf_evsel
*evsel
, int nr_events
,
1342 const char *helpline
, const char *ev_name
,
1344 struct hist_browser_timer
*hbt
,
1346 struct perf_session_env
*env
)
1348 struct hists
*hists
= &evsel
->hists
;
1349 struct hist_browser
*browser
= hist_browser__new(hists
);
1350 struct branch_info
*bi
;
1351 struct pstack
*fstack
;
1356 char script_opt
[64];
1357 int delay_secs
= hbt
? hbt
->refresh
: 0;
1359 #define HIST_BROWSER_HELP_COMMON \
1360 "h/?/F1 Show this window\n" \
1362 "PGDN/SPACE Navigate\n" \
1363 "q/ESC/CTRL+C Exit browser\n\n" \
1364 "For multiple event sessions:\n\n" \
1365 "TAB/UNTAB Switch events\n\n" \
1366 "For symbolic views (--sort has sym):\n\n" \
1367 "-> Zoom into DSO/Threads & Annotate current symbol\n" \
1369 "a Annotate current symbol\n" \
1370 "C Collapse all callchains\n" \
1371 "d Zoom into current DSO\n" \
1372 "E Expand all callchains\n" \
1374 /* help messages are sorted by lexical order of the hotkey */
1375 const char report_help
[] = HIST_BROWSER_HELP_COMMON
1376 "i Show header information\n"
1377 "P Print histograms to perf.hist.N\n"
1378 "r Run available scripts\n"
1379 "s Switch to another data file in PWD\n"
1380 "t Zoom into current Thread\n"
1381 "V Verbose (DSO names in callchains, etc)\n"
1382 "/ Filter symbol by name";
1383 const char top_help
[] = HIST_BROWSER_HELP_COMMON
1384 "P Print histograms to perf.hist.N\n"
1385 "t Zoom into current Thread\n"
1386 "V Verbose (DSO names in callchains, etc)\n"
1387 "/ Filter symbol by name";
1389 if (browser
== NULL
)
1393 browser
->min_pcnt
= min_pcnt
;
1394 hist_browser__update_pcnt_entries(browser
);
1397 fstack
= pstack__new(2);
1401 ui_helpline__push(helpline
);
1403 memset(options
, 0, sizeof(options
));
1406 const struct thread
*thread
= NULL
;
1407 const struct dso
*dso
= NULL
;
1409 annotate
= -2, zoom_dso
= -2, zoom_thread
= -2,
1410 annotate_f
= -2, annotate_t
= -2, browse_map
= -2;
1411 int scripts_comm
= -2, scripts_symbol
= -2,
1412 scripts_all
= -2, switch_data
= -2;
1416 key
= hist_browser__run(browser
, ev_name
, hbt
);
1418 if (browser
->he_selection
!= NULL
) {
1419 thread
= hist_browser__selected_thread(browser
);
1420 dso
= browser
->selection
->map
? browser
->selection
->map
->dso
: NULL
;
1428 * Exit the browser, let hists__browser_tree
1429 * go to the next or previous
1431 goto out_free_stack
;
1433 if (!sort__has_sym
) {
1434 ui_browser__warning(&browser
->b
, delay_secs
* 2,
1435 "Annotation is only available for symbolic views, "
1436 "include \"sym*\" in --sort to use it.");
1440 if (browser
->selection
== NULL
||
1441 browser
->selection
->sym
== NULL
||
1442 browser
->selection
->map
->dso
->annotate_warned
)
1446 hist_browser__dump(browser
);
1451 browser
->show_dso
= !browser
->show_dso
;
1456 if (ui_browser__input_window("Symbol to show",
1457 "Please enter the name of symbol you want to see",
1458 buf
, "ENTER: OK, ESC: Cancel",
1459 delay_secs
* 2) == K_ENTER
) {
1460 hists
->symbol_filter_str
= *buf
? buf
: NULL
;
1461 hists__filter_by_symbol(hists
);
1462 hist_browser__reset(browser
);
1466 if (is_report_browser(hbt
))
1470 if (is_report_browser(hbt
))
1471 goto do_data_switch
;
1474 /* env->arch is NULL for live-mode (i.e. perf top) */
1476 tui__header_window(env
);
1481 ui_browser__help_window(&browser
->b
,
1482 is_report_browser(hbt
) ? report_help
: top_help
);
1491 if (pstack__empty(fstack
)) {
1493 * Go back to the perf_evsel_menu__run or other user
1496 goto out_free_stack
;
1499 top
= pstack__pop(fstack
);
1500 if (top
== &browser
->hists
->dso_filter
)
1502 if (top
== &browser
->hists
->thread_filter
)
1503 goto zoom_out_thread
;
1508 !ui_browser__dialog_yesno(&browser
->b
,
1509 "Do you really want to exit?"))
1514 goto out_free_stack
;
1520 goto add_exit_option
;
1522 if (sort__mode
== SORT_MODE__BRANCH
) {
1523 bi
= browser
->he_selection
->branch_info
;
1524 if (browser
->selection
!= NULL
&&
1526 bi
->from
.sym
!= NULL
&&
1527 !bi
->from
.map
->dso
->annotate_warned
&&
1528 asprintf(&options
[nr_options
], "Annotate %s",
1529 bi
->from
.sym
->name
) > 0)
1530 annotate_f
= nr_options
++;
1532 if (browser
->selection
!= NULL
&&
1534 bi
->to
.sym
!= NULL
&&
1535 !bi
->to
.map
->dso
->annotate_warned
&&
1536 (bi
->to
.sym
!= bi
->from
.sym
||
1537 bi
->to
.map
->dso
!= bi
->from
.map
->dso
) &&
1538 asprintf(&options
[nr_options
], "Annotate %s",
1539 bi
->to
.sym
->name
) > 0)
1540 annotate_t
= nr_options
++;
1543 if (browser
->selection
!= NULL
&&
1544 browser
->selection
->sym
!= NULL
&&
1545 !browser
->selection
->map
->dso
->annotate_warned
&&
1546 asprintf(&options
[nr_options
], "Annotate %s",
1547 browser
->selection
->sym
->name
) > 0)
1548 annotate
= nr_options
++;
1551 if (thread
!= NULL
&&
1552 asprintf(&options
[nr_options
], "Zoom %s %s(%d) thread",
1553 (browser
->hists
->thread_filter
? "out of" : "into"),
1554 (thread
->comm_set
? thread__comm_str(thread
) : ""),
1556 zoom_thread
= nr_options
++;
1559 asprintf(&options
[nr_options
], "Zoom %s %s DSO",
1560 (browser
->hists
->dso_filter
? "out of" : "into"),
1561 (dso
->kernel
? "the Kernel" : dso
->short_name
)) > 0)
1562 zoom_dso
= nr_options
++;
1564 if (browser
->selection
!= NULL
&&
1565 browser
->selection
->map
!= NULL
&&
1566 asprintf(&options
[nr_options
], "Browse map details") > 0)
1567 browse_map
= nr_options
++;
1569 /* perf script support */
1570 if (browser
->he_selection
) {
1573 if (asprintf(&options
[nr_options
], "Run scripts for samples of thread [%s]",
1574 thread__comm_str(browser
->he_selection
->thread
)) > 0)
1575 scripts_comm
= nr_options
++;
1577 sym
= browser
->he_selection
->ms
.sym
;
1578 if (sym
&& sym
->namelen
&&
1579 asprintf(&options
[nr_options
], "Run scripts for samples of symbol [%s]",
1581 scripts_symbol
= nr_options
++;
1584 if (asprintf(&options
[nr_options
], "Run scripts for all samples") > 0)
1585 scripts_all
= nr_options
++;
1587 if (is_report_browser(hbt
) && asprintf(&options
[nr_options
],
1588 "Switch to another data file in PWD") > 0)
1589 switch_data
= nr_options
++;
1591 options
[nr_options
++] = (char *)"Exit";
1593 choice
= ui__popup_menu(nr_options
, options
);
1595 if (choice
== nr_options
- 1)
1599 free_popup_options(options
, nr_options
- 1);
1603 if (choice
== annotate
|| choice
== annotate_t
|| choice
== annotate_f
) {
1604 struct hist_entry
*he
;
1607 if (!objdump_path
&& perf_session_env__lookup_objdump(env
))
1610 he
= hist_browser__selected_entry(browser
);
1615 * we stash the branch_info symbol + map into the
1616 * the ms so we don't have to rewrite all the annotation
1617 * code to use branch_info.
1618 * in branch mode, the ms struct is not used
1620 if (choice
== annotate_f
) {
1621 he
->ms
.sym
= he
->branch_info
->from
.sym
;
1622 he
->ms
.map
= he
->branch_info
->from
.map
;
1623 } else if (choice
== annotate_t
) {
1624 he
->ms
.sym
= he
->branch_info
->to
.sym
;
1625 he
->ms
.map
= he
->branch_info
->to
.map
;
1629 * Don't let this be freed, say, by hists__decay_entry.
1632 err
= hist_entry__tui_annotate(he
, evsel
, hbt
);
1635 * offer option to annotate the other branch source or target
1636 * (if they exists) when returning from annotate
1638 if ((err
== 'q' || err
== CTRL('c'))
1639 && annotate_t
!= -2 && annotate_f
!= -2)
1640 goto retry_popup_menu
;
1642 ui_browser__update_nr_entries(&browser
->b
, browser
->hists
->nr_entries
);
1644 ui_browser__handle_resize(&browser
->b
);
1646 } else if (choice
== browse_map
)
1647 map__browse(browser
->selection
->map
);
1648 else if (choice
== zoom_dso
) {
1650 if (browser
->hists
->dso_filter
) {
1651 pstack__remove(fstack
, &browser
->hists
->dso_filter
);
1654 browser
->hists
->dso_filter
= NULL
;
1655 sort_dso
.elide
= false;
1659 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
1660 dso
->kernel
? "the Kernel" : dso
->short_name
);
1661 browser
->hists
->dso_filter
= dso
;
1662 sort_dso
.elide
= true;
1663 pstack__push(fstack
, &browser
->hists
->dso_filter
);
1665 hists__filter_by_dso(hists
);
1666 hist_browser__reset(browser
);
1667 } else if (choice
== zoom_thread
) {
1669 if (browser
->hists
->thread_filter
) {
1670 pstack__remove(fstack
, &browser
->hists
->thread_filter
);
1673 browser
->hists
->thread_filter
= NULL
;
1674 sort_thread
.elide
= false;
1676 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
1677 thread
->comm_set
? thread__comm_str(thread
) : "",
1679 browser
->hists
->thread_filter
= thread
;
1680 sort_thread
.elide
= true;
1681 pstack__push(fstack
, &browser
->hists
->thread_filter
);
1683 hists__filter_by_thread(hists
);
1684 hist_browser__reset(browser
);
1686 /* perf scripts support */
1687 else if (choice
== scripts_all
|| choice
== scripts_comm
||
1688 choice
== scripts_symbol
) {
1690 memset(script_opt
, 0, 64);
1692 if (choice
== scripts_comm
)
1693 sprintf(script_opt
, " -c %s ", thread__comm_str(browser
->he_selection
->thread
));
1695 if (choice
== scripts_symbol
)
1696 sprintf(script_opt
, " -S %s ", browser
->he_selection
->ms
.sym
->name
);
1698 script_browse(script_opt
);
1700 /* Switch to another data file */
1701 else if (choice
== switch_data
) {
1703 if (!switch_data_file()) {
1704 key
= K_SWITCH_INPUT_DATA
;
1707 ui__warning("Won't switch the data files due to\n"
1708 "no valid data file get selected!\n");
1712 pstack__delete(fstack
);
1714 hist_browser__delete(browser
);
1715 free_popup_options(options
, nr_options
- 1);
1719 struct perf_evsel_menu
{
1720 struct ui_browser b
;
1721 struct perf_evsel
*selection
;
1722 bool lost_events
, lost_events_warned
;
1724 struct perf_session_env
*env
;
1727 static void perf_evsel_menu__write(struct ui_browser
*browser
,
1728 void *entry
, int row
)
1730 struct perf_evsel_menu
*menu
= container_of(browser
,
1731 struct perf_evsel_menu
, b
);
1732 struct perf_evsel
*evsel
= list_entry(entry
, struct perf_evsel
, node
);
1733 bool current_entry
= ui_browser__is_current_entry(browser
, row
);
1734 unsigned long nr_events
= evsel
->hists
.stats
.nr_events
[PERF_RECORD_SAMPLE
];
1735 const char *ev_name
= perf_evsel__name(evsel
);
1737 const char *warn
= " ";
1740 ui_browser__set_color(browser
, current_entry
? HE_COLORSET_SELECTED
:
1741 HE_COLORSET_NORMAL
);
1743 if (perf_evsel__is_group_event(evsel
)) {
1744 struct perf_evsel
*pos
;
1746 ev_name
= perf_evsel__group_name(evsel
);
1748 for_each_group_member(pos
, evsel
) {
1749 nr_events
+= pos
->hists
.stats
.nr_events
[PERF_RECORD_SAMPLE
];
1753 nr_events
= convert_unit(nr_events
, &unit
);
1754 printed
= scnprintf(bf
, sizeof(bf
), "%lu%c%s%s", nr_events
,
1755 unit
, unit
== ' ' ? "" : " ", ev_name
);
1756 slsmg_printf("%s", bf
);
1758 nr_events
= evsel
->hists
.stats
.nr_events
[PERF_RECORD_LOST
];
1759 if (nr_events
!= 0) {
1760 menu
->lost_events
= true;
1762 ui_browser__set_color(browser
, HE_COLORSET_TOP
);
1763 nr_events
= convert_unit(nr_events
, &unit
);
1764 printed
+= scnprintf(bf
, sizeof(bf
), ": %ld%c%schunks LOST!",
1765 nr_events
, unit
, unit
== ' ' ? "" : " ");
1769 slsmg_write_nstring(warn
, browser
->width
- printed
);
1772 menu
->selection
= evsel
;
1775 static int perf_evsel_menu__run(struct perf_evsel_menu
*menu
,
1776 int nr_events
, const char *help
,
1777 struct hist_browser_timer
*hbt
)
1779 struct perf_evlist
*evlist
= menu
->b
.priv
;
1780 struct perf_evsel
*pos
;
1781 const char *ev_name
, *title
= "Available samples";
1782 int delay_secs
= hbt
? hbt
->refresh
: 0;
1785 if (ui_browser__show(&menu
->b
, title
,
1786 "ESC: exit, ENTER|->: Browse histograms") < 0)
1790 key
= ui_browser__run(&menu
->b
, delay_secs
);
1794 hbt
->timer(hbt
->arg
);
1796 if (!menu
->lost_events_warned
&& menu
->lost_events
) {
1797 ui_browser__warn_lost_events(&menu
->b
);
1798 menu
->lost_events_warned
= true;
1803 if (!menu
->selection
)
1805 pos
= menu
->selection
;
1807 perf_evlist__set_selected(evlist
, pos
);
1809 * Give the calling tool a chance to populate the non
1810 * default evsel resorted hists tree.
1813 hbt
->timer(hbt
->arg
);
1814 ev_name
= perf_evsel__name(pos
);
1815 key
= perf_evsel__hists_browse(pos
, nr_events
, help
,
1819 ui_browser__show_title(&menu
->b
, title
);
1822 if (pos
->node
.next
== &evlist
->entries
)
1823 pos
= perf_evlist__first(evlist
);
1825 pos
= perf_evsel__next(pos
);
1828 if (pos
->node
.prev
== &evlist
->entries
)
1829 pos
= perf_evlist__last(evlist
);
1831 pos
= perf_evsel__prev(pos
);
1834 if (!ui_browser__dialog_yesno(&menu
->b
,
1835 "Do you really want to exit?"))
1838 case K_SWITCH_INPUT_DATA
:
1848 if (!ui_browser__dialog_yesno(&menu
->b
,
1849 "Do you really want to exit?"))
1861 ui_browser__hide(&menu
->b
);
1865 static bool filter_group_entries(struct ui_browser
*browser __maybe_unused
,
1868 struct perf_evsel
*evsel
= list_entry(entry
, struct perf_evsel
, node
);
1870 if (symbol_conf
.event_group
&& !perf_evsel__is_group_leader(evsel
))
1876 static int __perf_evlist__tui_browse_hists(struct perf_evlist
*evlist
,
1877 int nr_entries
, const char *help
,
1878 struct hist_browser_timer
*hbt
,
1880 struct perf_session_env
*env
)
1882 struct perf_evsel
*pos
;
1883 struct perf_evsel_menu menu
= {
1885 .entries
= &evlist
->entries
,
1886 .refresh
= ui_browser__list_head_refresh
,
1887 .seek
= ui_browser__list_head_seek
,
1888 .write
= perf_evsel_menu__write
,
1889 .filter
= filter_group_entries
,
1890 .nr_entries
= nr_entries
,
1893 .min_pcnt
= min_pcnt
,
1897 ui_helpline__push("Press ESC to exit");
1899 evlist__for_each(evlist
, pos
) {
1900 const char *ev_name
= perf_evsel__name(pos
);
1901 size_t line_len
= strlen(ev_name
) + 7;
1903 if (menu
.b
.width
< line_len
)
1904 menu
.b
.width
= line_len
;
1907 return perf_evsel_menu__run(&menu
, nr_entries
, help
, hbt
);
1910 int perf_evlist__tui_browse_hists(struct perf_evlist
*evlist
, const char *help
,
1911 struct hist_browser_timer
*hbt
,
1913 struct perf_session_env
*env
)
1915 int nr_entries
= evlist
->nr_entries
;
1918 if (nr_entries
== 1) {
1919 struct perf_evsel
*first
= perf_evlist__first(evlist
);
1920 const char *ev_name
= perf_evsel__name(first
);
1922 return perf_evsel__hists_browse(first
, nr_entries
, help
,
1923 ev_name
, false, hbt
, min_pcnt
,
1927 if (symbol_conf
.event_group
) {
1928 struct perf_evsel
*pos
;
1931 evlist__for_each(evlist
, pos
) {
1932 if (perf_evsel__is_group_leader(pos
))
1936 if (nr_entries
== 1)
1940 return __perf_evlist__tui_browse_hists(evlist
, nr_entries
, help
,
1941 hbt
, min_pcnt
, env
);