projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'picoxcell/timer' into next/timer
[deliverable/linux.git] / tools / perf / ui / browsers / hists.c
1 #include <stdio.h>
2 #include "../libslang.h"
3 #include <stdlib.h>
4 #include <string.h>
5 #include <newt.h>
6 #include <linux/rbtree.h>
7
8 #include "../../util/evsel.h"
9 #include "../../util/evlist.h"
10 #include "../../util/hist.h"
11 #include "../../util/pstack.h"
12 #include "../../util/sort.h"
13 #include "../../util/util.h"
14
15 #include "../browser.h"
16 #include "../helpline.h"
17 #include "../util.h"
18 #include "../ui.h"
19 #include "map.h"
20
21 struct hist_browser {
22 struct ui_browser b;
23 struct hists *hists;
24 struct hist_entry *he_selection;
25 struct map_symbol *selection;
26 bool has_symbols;
27 };
28
29 static int hists__browser_title(struct hists *hists, char *bf, size_t size,
30 const char *ev_name);
31
32 static void hist_browser__refresh_dimensions(struct hist_browser *browser)
33 {
34 /* 3 == +/- toggle symbol before actual hist_entry rendering */
35 browser->b.width = 3 + (hists__sort_list_width(browser->hists) +
36 sizeof("[k]"));
37 }
38
39 static void hist_browser__reset(struct hist_browser *browser)
40 {
41 browser->b.nr_entries = browser->hists->nr_entries;
42 hist_browser__refresh_dimensions(browser);
43 ui_browser__reset_index(&browser->b);
44 }
45
46 static char tree__folded_sign(bool unfolded)
47 {
48 return unfolded ? '-' : '+';
49 }
50
51 static char map_symbol__folded(const struct map_symbol *ms)
52 {
53 return ms->has_children ? tree__folded_sign(ms->unfolded) : ' ';
54 }
55
56 static char hist_entry__folded(const struct hist_entry *he)
57 {
58 return map_symbol__folded(&he->ms);
59 }
60
61 static char callchain_list__folded(const struct callchain_list *cl)
62 {
63 return map_symbol__folded(&cl->ms);
64 }
65
66 static void map_symbol__set_folding(struct map_symbol *ms, bool unfold)
67 {
68 ms->unfolded = unfold ? ms->has_children : false;
69 }
70
71 static int callchain_node__count_rows_rb_tree(struct callchain_node *node)
72 {
73 int n = 0;
74 struct rb_node *nd;
75
76 for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
77 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
78 struct callchain_list *chain;
79 char folded_sign = ' '; /* No children */
80
81 list_for_each_entry(chain, &child->val, list) {
82 ++n;
83 /* We need this because we may not have children */
84 folded_sign = callchain_list__folded(chain);
85 if (folded_sign == '+')
86 break;
87 }
88
89 if (folded_sign == '-') /* Have children and they're unfolded */
90 n += callchain_node__count_rows_rb_tree(child);
91 }
92
93 return n;
94 }
95
96 static int callchain_node__count_rows(struct callchain_node *node)
97 {
98 struct callchain_list *chain;
99 bool unfolded = false;
100 int n = 0;
101
102 list_for_each_entry(chain, &node->val, list) {
103 ++n;
104 unfolded = chain->ms.unfolded;
105 }
106
107 if (unfolded)
108 n += callchain_node__count_rows_rb_tree(node);
109
110 return n;
111 }
112
113 static int callchain__count_rows(struct rb_root *chain)
114 {
115 struct rb_node *nd;
116 int n = 0;
117
118 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
119 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
120 n += callchain_node__count_rows(node);
121 }
122
123 return n;
124 }
125
126 static bool map_symbol__toggle_fold(struct map_symbol *ms)
127 {
128 if (!ms)
129 return false;
130
131 if (!ms->has_children)
132 return false;
133
134 ms->unfolded = !ms->unfolded;
135 return true;
136 }
137
138 static void callchain_node__init_have_children_rb_tree(struct callchain_node *node)
139 {
140 struct rb_node *nd = rb_first(&node->rb_root);
141
142 for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
143 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
144 struct callchain_list *chain;
145 bool first = true;
146
147 list_for_each_entry(chain, &child->val, list) {
148 if (first) {
149 first = false;
150 chain->ms.has_children = chain->list.next != &child->val ||
151 !RB_EMPTY_ROOT(&child->rb_root);
152 } else
153 chain->ms.has_children = chain->list.next == &child->val &&
154 !RB_EMPTY_ROOT(&child->rb_root);
155 }
156
157 callchain_node__init_have_children_rb_tree(child);
158 }
159 }
160
161 static void callchain_node__init_have_children(struct callchain_node *node)
162 {
163 struct callchain_list *chain;
164
165 list_for_each_entry(chain, &node->val, list)
166 chain->ms.has_children = !RB_EMPTY_ROOT(&node->rb_root);
167
168 callchain_node__init_have_children_rb_tree(node);
169 }
170
171 static void callchain__init_have_children(struct rb_root *root)
172 {
173 struct rb_node *nd;
174
175 for (nd = rb_first(root); nd; nd = rb_next(nd)) {
176 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
177 callchain_node__init_have_children(node);
178 }
179 }
180
181 static void hist_entry__init_have_children(struct hist_entry *he)
182 {
183 if (!he->init_have_children) {
184 he->ms.has_children = !RB_EMPTY_ROOT(&he->sorted_chain);
185 callchain__init_have_children(&he->sorted_chain);
186 he->init_have_children = true;
187 }
188 }
189
190 static bool hist_browser__toggle_fold(struct hist_browser *browser)
191 {
192 if (map_symbol__toggle_fold(browser->selection)) {
193 struct hist_entry *he = browser->he_selection;
194
195 hist_entry__init_have_children(he);
196 browser->hists->nr_entries -= he->nr_rows;
197
198 if (he->ms.unfolded)
199 he->nr_rows = callchain__count_rows(&he->sorted_chain);
200 else
201 he->nr_rows = 0;
202 browser->hists->nr_entries += he->nr_rows;
203 browser->b.nr_entries = browser->hists->nr_entries;
204
205 return true;
206 }
207
208 /* If it doesn't have children, no toggling performed */
209 return false;
210 }
211
212 static int callchain_node__set_folding_rb_tree(struct callchain_node *node, bool unfold)
213 {
214 int n = 0;
215 struct rb_node *nd;
216
217 for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
218 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
219 struct callchain_list *chain;
220 bool has_children = false;
221
222 list_for_each_entry(chain, &child->val, list) {
223 ++n;
224 map_symbol__set_folding(&chain->ms, unfold);
225 has_children = chain->ms.has_children;
226 }
227
228 if (has_children)
229 n += callchain_node__set_folding_rb_tree(child, unfold);
230 }
231
232 return n;
233 }
234
235 static int callchain_node__set_folding(struct callchain_node *node, bool unfold)
236 {
237 struct callchain_list *chain;
238 bool has_children = false;
239 int n = 0;
240
241 list_for_each_entry(chain, &node->val, list) {
242 ++n;
243 map_symbol__set_folding(&chain->ms, unfold);
244 has_children = chain->ms.has_children;
245 }
246
247 if (has_children)
248 n += callchain_node__set_folding_rb_tree(node, unfold);
249
250 return n;
251 }
252
253 static int callchain__set_folding(struct rb_root *chain, bool unfold)
254 {
255 struct rb_node *nd;
256 int n = 0;
257
258 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
259 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
260 n += callchain_node__set_folding(node, unfold);
261 }
262
263 return n;
264 }
265
266 static void hist_entry__set_folding(struct hist_entry *he, bool unfold)
267 {
268 hist_entry__init_have_children(he);
269 map_symbol__set_folding(&he->ms, unfold);
270
271 if (he->ms.has_children) {
272 int n = callchain__set_folding(&he->sorted_chain, unfold);
273 he->nr_rows = unfold ? n : 0;
274 } else
275 he->nr_rows = 0;
276 }
277
278 static void hists__set_folding(struct hists *hists, bool unfold)
279 {
280 struct rb_node *nd;
281
282 hists->nr_entries = 0;
283
284 for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
285 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
286 hist_entry__set_folding(he, unfold);
287 hists->nr_entries += 1 + he->nr_rows;
288 }
289 }
290
291 static void hist_browser__set_folding(struct hist_browser *browser, bool unfold)
292 {
293 hists__set_folding(browser->hists, unfold);
294 browser->b.nr_entries = browser->hists->nr_entries;
295 /* Go to the start, we may be way after valid entries after a collapse */
296 ui_browser__reset_index(&browser->b);
297 }
298
299 static void ui_browser__warn_lost_events(struct ui_browser *browser)
300 {
301 ui_browser__warning(browser, 4,
302 "Events are being lost, check IO/CPU overload!\n\n"
303 "You may want to run 'perf' using a RT scheduler policy:\n\n"
304 " perf top -r 80\n\n"
305 "Or reduce the sampling frequency.");
306 }
307
308 static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
309 void(*timer)(void *arg), void *arg, int delay_secs)
310 {
311 int key;
312 char title[160];
313
314 browser->b.entries = &browser->hists->entries;
315 browser->b.nr_entries = browser->hists->nr_entries;
316
317 hist_browser__refresh_dimensions(browser);
318 hists__browser_title(browser->hists, title, sizeof(title), ev_name);
319
320 if (ui_browser__show(&browser->b, title,
321 "Press '?' for help on key bindings") < 0)
322 return -1;
323
324 while (1) {
325 key = ui_browser__run(&browser->b, delay_secs);
326
327 switch (key) {
328 case K_TIMER:
329 timer(arg);
330 ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
331
332 if (browser->hists->stats.nr_lost_warned !=
333 browser->hists->stats.nr_events[PERF_RECORD_LOST]) {
334 browser->hists->stats.nr_lost_warned =
335 browser->hists->stats.nr_events[PERF_RECORD_LOST];
336 ui_browser__warn_lost_events(&browser->b);
337 }
338
339 hists__browser_title(browser->hists, title, sizeof(title), ev_name);
340 ui_browser__show_title(&browser->b, title);
341 continue;
342 case 'D': { /* Debug */
343 static int seq;
344 struct hist_entry *h = rb_entry(browser->b.top,
345 struct hist_entry, rb_node);
346 ui_helpline__pop();
347 ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
348 seq++, browser->b.nr_entries,
349 browser->hists->nr_entries,
350 browser->b.height,
351 browser->b.index,
352 browser->b.top_idx,
353 h->row_offset, h->nr_rows);
354 }
355 break;
356 case 'C':
357 /* Collapse the whole world. */
358 hist_browser__set_folding(browser, false);
359 break;
360 case 'E':
361 /* Expand the whole world. */
362 hist_browser__set_folding(browser, true);
363 break;
364 case K_ENTER:
365 if (hist_browser__toggle_fold(browser))
366 break;
367 /* fall thru */
368 default:
369 goto out;
370 }
371 }
372 out:
373 ui_browser__hide(&browser->b);
374 return key;
375 }
376
377 static char *callchain_list__sym_name(struct callchain_list *cl,
378 char *bf, size_t bfsize)
379 {
380 if (cl->ms.sym)
381 return cl->ms.sym->name;
382
383 snprintf(bf, bfsize, "%#" PRIx64, cl->ip);
384 return bf;
385 }
386
387 #define LEVEL_OFFSET_STEP 3
388
389 static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *browser,
390 struct callchain_node *chain_node,
391 u64 total, int level,
392 unsigned short row,
393 off_t *row_offset,
394 bool *is_current_entry)
395 {
396 struct rb_node *node;
397 int first_row = row, width, offset = level * LEVEL_OFFSET_STEP;
398 u64 new_total, remaining;
399
400 if (callchain_param.mode == CHAIN_GRAPH_REL)
401 new_total = chain_node->children_hit;
402 else
403 new_total = total;
404
405 remaining = new_total;
406 node = rb_first(&chain_node->rb_root);
407 while (node) {
408 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
409 struct rb_node *next = rb_next(node);
410 u64 cumul = callchain_cumul_hits(child);
411 struct callchain_list *chain;
412 char folded_sign = ' ';
413 int first = true;
414 int extra_offset = 0;
415
416 remaining -= cumul;
417
418 list_for_each_entry(chain, &child->val, list) {
419 char ipstr[BITS_PER_LONG / 4 + 1], *alloc_str;
420 const char *str;
421 int color;
422 bool was_first = first;
423
424 if (first)
425 first = false;
426 else
427 extra_offset = LEVEL_OFFSET_STEP;
428
429 folded_sign = callchain_list__folded(chain);
430 if (*row_offset != 0) {
431 --*row_offset;
432 goto do_next;
433 }
434
435 alloc_str = NULL;
436 str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
437 if (was_first) {
438 double percent = cumul * 100.0 / new_total;
439
440 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
441 str = "Not enough memory!";
442 else
443 str = alloc_str;
444 }
445
446 color = HE_COLORSET_NORMAL;
447 width = browser->b.width - (offset + extra_offset + 2);
448 if (ui_browser__is_current_entry(&browser->b, row)) {
449 browser->selection = &chain->ms;
450 color = HE_COLORSET_SELECTED;
451 *is_current_entry = true;
452 }
453
454 ui_browser__set_color(&browser->b, color);
455 ui_browser__gotorc(&browser->b, row, 0);
456 slsmg_write_nstring(" ", offset + extra_offset);
457 slsmg_printf("%c ", folded_sign);
458 slsmg_write_nstring(str, width);
459 free(alloc_str);
460
461 if (++row == browser->b.height)
462 goto out;
463 do_next:
464 if (folded_sign == '+')
465 break;
466 }
467
468 if (folded_sign == '-') {
469 const int new_level = level + (extra_offset ? 2 : 1);
470 row += hist_browser__show_callchain_node_rb_tree(browser, child, new_total,
471 new_level, row, row_offset,
472 is_current_entry);
473 }
474 if (row == browser->b.height)
475 goto out;
476 node = next;
477 }
478 out:
479 return row - first_row;
480 }
481
482 static int hist_browser__show_callchain_node(struct hist_browser *browser,
483 struct callchain_node *node,
484 int level, unsigned short row,
485 off_t *row_offset,
486 bool *is_current_entry)
487 {
488 struct callchain_list *chain;
489 int first_row = row,
490 offset = level * LEVEL_OFFSET_STEP,
491 width = browser->b.width - offset;
492 char folded_sign = ' ';
493
494 list_for_each_entry(chain, &node->val, list) {
495 char ipstr[BITS_PER_LONG / 4 + 1], *s;
496 int color;
497
498 folded_sign = callchain_list__folded(chain);
499
500 if (*row_offset != 0) {
501 --*row_offset;
502 continue;
503 }
504
505 color = HE_COLORSET_NORMAL;
506 if (ui_browser__is_current_entry(&browser->b, row)) {
507 browser->selection = &chain->ms;
508 color = HE_COLORSET_SELECTED;
509 *is_current_entry = true;
510 }
511
512 s = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
513 ui_browser__gotorc(&browser->b, row, 0);
514 ui_browser__set_color(&browser->b, color);
515 slsmg_write_nstring(" ", offset);
516 slsmg_printf("%c ", folded_sign);
517 slsmg_write_nstring(s, width - 2);
518
519 if (++row == browser->b.height)
520 goto out;
521 }
522
523 if (folded_sign == '-')
524 row += hist_browser__show_callchain_node_rb_tree(browser, node,
525 browser->hists->stats.total_period,
526 level + 1, row,
527 row_offset,
528 is_current_entry);
529 out:
530 return row - first_row;
531 }
532
533 static int hist_browser__show_callchain(struct hist_browser *browser,
534 struct rb_root *chain,
535 int level, unsigned short row,
536 off_t *row_offset,
537 bool *is_current_entry)
538 {
539 struct rb_node *nd;
540 int first_row = row;
541
542 for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
543 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
544
545 row += hist_browser__show_callchain_node(browser, node, level,
546 row, row_offset,
547 is_current_entry);
548 if (row == browser->b.height)
549 break;
550 }
551
552 return row - first_row;
553 }
554
555 static int hist_browser__show_entry(struct hist_browser *browser,
556 struct hist_entry *entry,
557 unsigned short row)
558 {
559 char s[256];
560 double percent;
561 int printed = 0;
562 int width = browser->b.width - 6; /* The percentage */
563 char folded_sign = ' ';
564 bool current_entry = ui_browser__is_current_entry(&browser->b, row);
565 off_t row_offset = entry->row_offset;
566
567 if (current_entry) {
568 browser->he_selection = entry;
569 browser->selection = &entry->ms;
570 }
571
572 if (symbol_conf.use_callchain) {
573 hist_entry__init_have_children(entry);
574 folded_sign = hist_entry__folded(entry);
575 }
576
577 if (row_offset == 0) {
578 hist_entry__snprintf(entry, s, sizeof(s), browser->hists);
579 percent = (entry->period * 100.0) / browser->hists->stats.total_period;
580
581 ui_browser__set_percent_color(&browser->b, percent, current_entry);
582 ui_browser__gotorc(&browser->b, row, 0);
583 if (symbol_conf.use_callchain) {
584 slsmg_printf("%c ", folded_sign);
585 width -= 2;
586 }
587
588 slsmg_printf(" %5.2f%%", percent);
589
590 /* The scroll bar isn't being used */
591 if (!browser->b.navkeypressed)
592 width += 1;
593
594 if (!current_entry || !browser->b.navkeypressed)
595 ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
596
597 if (symbol_conf.show_nr_samples) {
598 slsmg_printf(" %11u", entry->nr_events);
599 width -= 12;
600 }
601
602 if (symbol_conf.show_total_period) {
603 slsmg_printf(" %12" PRIu64, entry->period);
604 width -= 13;
605 }
606
607 slsmg_write_nstring(s, width);
608 ++row;
609 ++printed;
610 } else
611 --row_offset;
612
613 if (folded_sign == '-' && row != browser->b.height) {
614 printed += hist_browser__show_callchain(browser, &entry->sorted_chain,
615 1, row, &row_offset,
616 &current_entry);
617 if (current_entry)
618 browser->he_selection = entry;
619 }
620
621 return printed;
622 }
623
624 static void ui_browser__hists_init_top(struct ui_browser *browser)
625 {
626 if (browser->top == NULL) {
627 struct hist_browser *hb;
628
629 hb = container_of(browser, struct hist_browser, b);
630 browser->top = rb_first(&hb->hists->entries);
631 }
632 }
633
634 static unsigned int hist_browser__refresh(struct ui_browser *browser)
635 {
636 unsigned row = 0;
637 struct rb_node *nd;
638 struct hist_browser *hb = container_of(browser, struct hist_browser, b);
639
640 ui_browser__hists_init_top(browser);
641
642 for (nd = browser->top; nd; nd = rb_next(nd)) {
643 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
644
645 if (h->filtered)
646 continue;
647
648 row += hist_browser__show_entry(hb, h, row);
649 if (row == browser->height)
650 break;
651 }
652
653 return row;
654 }
655
656 static struct rb_node *hists__filter_entries(struct rb_node *nd)
657 {
658 while (nd != NULL) {
659 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
660 if (!h->filtered)
661 return nd;
662
663 nd = rb_next(nd);
664 }
665
666 return NULL;
667 }
668
669 static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
670 {
671 while (nd != NULL) {
672 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
673 if (!h->filtered)
674 return nd;
675
676 nd = rb_prev(nd);
677 }
678
679 return NULL;
680 }
681
682 static void ui_browser__hists_seek(struct ui_browser *browser,
683 off_t offset, int whence)
684 {
685 struct hist_entry *h;
686 struct rb_node *nd;
687 bool first = true;
688
689 if (browser->nr_entries == 0)
690 return;
691
692 ui_browser__hists_init_top(browser);
693
694 switch (whence) {
695 case SEEK_SET:
696 nd = hists__filter_entries(rb_first(browser->entries));
697 break;
698 case SEEK_CUR:
699 nd = browser->top;
700 goto do_offset;
701 case SEEK_END:
702 nd = hists__filter_prev_entries(rb_last(browser->entries));
703 first = false;
704 break;
705 default:
706 return;
707 }
708
709 /*
710 * Moves not relative to the first visible entry invalidates its
711 * row_offset:
712 */
713 h = rb_entry(browser->top, struct hist_entry, rb_node);
714 h->row_offset = 0;
715
716 /*
717 * Here we have to check if nd is expanded (+), if it is we can't go
718 * the next top level hist_entry, instead we must compute an offset of
719 * what _not_ to show and not change the first visible entry.
720 *
721 * This offset increments when we are going from top to bottom and
722 * decreases when we're going from bottom to top.
723 *
724 * As we don't have backpointers to the top level in the callchains
725 * structure, we need to always print the whole hist_entry callchain,
726 * skipping the first ones that are before the first visible entry
727 * and stop when we printed enough lines to fill the screen.
728 */
729 do_offset:
730 if (offset > 0) {
731 do {
732 h = rb_entry(nd, struct hist_entry, rb_node);
733 if (h->ms.unfolded) {
734 u16 remaining = h->nr_rows - h->row_offset;
735 if (offset > remaining) {
736 offset -= remaining;
737 h->row_offset = 0;
738 } else {
739 h->row_offset += offset;
740 offset = 0;
741 browser->top = nd;
742 break;
743 }
744 }
745 nd = hists__filter_entries(rb_next(nd));
746 if (nd == NULL)
747 break;
748 --offset;
749 browser->top = nd;
750 } while (offset != 0);
751 } else if (offset < 0) {
752 while (1) {
753 h = rb_entry(nd, struct hist_entry, rb_node);
754 if (h->ms.unfolded) {
755 if (first) {
756 if (-offset > h->row_offset) {
757 offset += h->row_offset;
758 h->row_offset = 0;
759 } else {
760 h->row_offset += offset;
761 offset = 0;
762 browser->top = nd;
763 break;
764 }
765 } else {
766 if (-offset > h->nr_rows) {
767 offset += h->nr_rows;
768 h->row_offset = 0;
769 } else {
770 h->row_offset = h->nr_rows + offset;
771 offset = 0;
772 browser->top = nd;
773 break;
774 }
775 }
776 }
777
778 nd = hists__filter_prev_entries(rb_prev(nd));
779 if (nd == NULL)
780 break;
781 ++offset;
782 browser->top = nd;
783 if (offset == 0) {
784 /*
785 * Last unfiltered hist_entry, check if it is
786 * unfolded, if it is then we should have
787 * row_offset at its last entry.
788 */
789 h = rb_entry(nd, struct hist_entry, rb_node);
790 if (h->ms.unfolded)
791 h->row_offset = h->nr_rows;
792 break;
793 }
794 first = false;
795 }
796 } else {
797 browser->top = nd;
798 h = rb_entry(nd, struct hist_entry, rb_node);
799 h->row_offset = 0;
800 }
801 }
802
803 static struct hist_browser *hist_browser__new(struct hists *hists)
804 {
805 struct hist_browser *browser = zalloc(sizeof(*browser));
806
807 if (browser) {
808 browser->hists = hists;
809 browser->b.refresh = hist_browser__refresh;
810 browser->b.seek = ui_browser__hists_seek;
811 browser->b.use_navkeypressed = true;
812 if (sort__branch_mode == 1)
813 browser->has_symbols = sort_sym_from.list.next != NULL;
814 else
815 browser->has_symbols = sort_sym.list.next != NULL;
816 }
817
818 return browser;
819 }
820
821 static void hist_browser__delete(struct hist_browser *browser)
822 {
823 free(browser);
824 }
825
826 static struct hist_entry *hist_browser__selected_entry(struct hist_browser *browser)
827 {
828 return browser->he_selection;
829 }
830
831 static struct thread *hist_browser__selected_thread(struct hist_browser *browser)
832 {
833 return browser->he_selection->thread;
834 }
835
836 static int hists__browser_title(struct hists *hists, char *bf, size_t size,
837 const char *ev_name)
838 {
839 char unit;
840 int printed;
841 const struct dso *dso = hists->dso_filter;
842 const struct thread *thread = hists->thread_filter;
843 unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
844 u64 nr_events = hists->stats.total_period;
845
846 nr_samples = convert_unit(nr_samples, &unit);
847 printed = scnprintf(bf, size,
848 "Samples: %lu%c of event '%s', Event count (approx.): %lu",
849 nr_samples, unit, ev_name, nr_events);
850
851
852 if (hists->uid_filter_str)
853 printed += snprintf(bf + printed, size - printed,
854 ", UID: %s", hists->uid_filter_str);
855 if (thread)
856 printed += scnprintf(bf + printed, size - printed,
857 ", Thread: %s(%d)",
858 (thread->comm_set ? thread->comm : ""),
859 thread->pid);
860 if (dso)
861 printed += scnprintf(bf + printed, size - printed,
862 ", DSO: %s", dso->short_name);
863 return printed;
864 }
865
866 static inline void free_popup_options(char **options, int n)
867 {
868 int i;
869
870 for (i = 0; i < n; ++i) {
871 free(options[i]);
872 options[i] = NULL;
873 }
874 }
875
876 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
877 const char *helpline, const char *ev_name,
878 bool left_exits,
879 void(*timer)(void *arg), void *arg,
880 int delay_secs)
881 {
882 struct hists *hists = &evsel->hists;
883 struct hist_browser *browser = hist_browser__new(hists);
884 struct branch_info *bi;
885 struct pstack *fstack;
886 char *options[16];
887 int nr_options = 0;
888 int key = -1;
889 char buf[64];
890
891 if (browser == NULL)
892 return -1;
893
894 fstack = pstack__new(2);
895 if (fstack == NULL)
896 goto out;
897
898 ui_helpline__push(helpline);
899
900 memset(options, 0, sizeof(options));
901
902 while (1) {
903 const struct thread *thread = NULL;
904 const struct dso *dso = NULL;
905 int choice = 0,
906 annotate = -2, zoom_dso = -2, zoom_thread = -2,
907 annotate_f = -2, annotate_t = -2, browse_map = -2;
908
909 nr_options = 0;
910
911 key = hist_browser__run(browser, ev_name, timer, arg, delay_secs);
912
913 if (browser->he_selection != NULL) {
914 thread = hist_browser__selected_thread(browser);
915 dso = browser->selection->map ? browser->selection->map->dso : NULL;
916 }
917 switch (key) {
918 case K_TAB:
919 case K_UNTAB:
920 if (nr_events == 1)
921 continue;
922 /*
923 * Exit the browser, let hists__browser_tree
924 * go to the next or previous
925 */
926 goto out_free_stack;
927 case 'a':
928 if (!browser->has_symbols) {
929 ui_browser__warning(&browser->b, delay_secs * 2,
930 "Annotation is only available for symbolic views, "
931 "include \"sym*\" in --sort to use it.");
932 continue;
933 }
934
935 if (browser->selection == NULL ||
936 browser->selection->sym == NULL ||
937 browser->selection->map->dso->annotate_warned)
938 continue;
939 goto do_annotate;
940 case 'd':
941 goto zoom_dso;
942 case 't':
943 goto zoom_thread;
944 case '/':
945 if (ui_browser__input_window("Symbol to show",
946 "Please enter the name of symbol you want to see",
947 buf, "ENTER: OK, ESC: Cancel",
948 delay_secs * 2) == K_ENTER) {
949 hists->symbol_filter_str = *buf ? buf : NULL;
950 hists__filter_by_symbol(hists);
951 hist_browser__reset(browser);
952 }
953 continue;
954 case K_F1:
955 case 'h':
956 case '?':
957 ui_browser__help_window(&browser->b,
958 "h/?/F1 Show this window\n"
959 "UP/DOWN/PGUP\n"
960 "PGDN/SPACE Navigate\n"
961 "q/ESC/CTRL+C Exit browser\n\n"
962 "For multiple event sessions:\n\n"
963 "TAB/UNTAB Switch events\n\n"
964 "For symbolic views (--sort has sym):\n\n"
965 "-> Zoom into DSO/Threads & Annotate current symbol\n"
966 "<- Zoom out\n"
967 "a Annotate current symbol\n"
968 "C Collapse all callchains\n"
969 "E Expand all callchains\n"
970 "d Zoom into current DSO\n"
971 "t Zoom into current Thread\n"
972 "/ Filter symbol by name");
973 continue;
974 case K_ENTER:
975 case K_RIGHT:
976 /* menu */
977 break;
978 case K_LEFT: {
979 const void *top;
980
981 if (pstack__empty(fstack)) {
982 /*
983 * Go back to the perf_evsel_menu__run or other user
984 */
985 if (left_exits)
986 goto out_free_stack;
987 continue;
988 }
989 top = pstack__pop(fstack);
990 if (top == &browser->hists->dso_filter)
991 goto zoom_out_dso;
992 if (top == &browser->hists->thread_filter)
993 goto zoom_out_thread;
994 continue;
995 }
996 case K_ESC:
997 if (!left_exits &&
998 !ui_browser__dialog_yesno(&browser->b,
999 "Do you really want to exit?"))
1000 continue;
1001 /* Fall thru */
1002 case 'q':
1003 case CTRL('c'):
1004 goto out_free_stack;
1005 default:
1006 continue;
1007 }
1008
1009 if (!browser->has_symbols)
1010 goto add_exit_option;
1011
1012 if (sort__branch_mode == 1) {
1013 bi = browser->he_selection->branch_info;
1014 if (browser->selection != NULL &&
1015 bi &&
1016 bi->from.sym != NULL &&
1017 !bi->from.map->dso->annotate_warned &&
1018 asprintf(&options[nr_options], "Annotate %s",
1019 bi->from.sym->name) > 0)
1020 annotate_f = nr_options++;
1021
1022 if (browser->selection != NULL &&
1023 bi &&
1024 bi->to.sym != NULL &&
1025 !bi->to.map->dso->annotate_warned &&
1026 (bi->to.sym != bi->from.sym ||
1027 bi->to.map->dso != bi->from.map->dso) &&
1028 asprintf(&options[nr_options], "Annotate %s",
1029 bi->to.sym->name) > 0)
1030 annotate_t = nr_options++;
1031 } else {
1032
1033 if (browser->selection != NULL &&
1034 browser->selection->sym != NULL &&
1035 !browser->selection->map->dso->annotate_warned &&
1036 asprintf(&options[nr_options], "Annotate %s",
1037 browser->selection->sym->name) > 0)
1038 annotate = nr_options++;
1039 }
1040
1041 if (thread != NULL &&
1042 asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
1043 (browser->hists->thread_filter ? "out of" : "into"),
1044 (thread->comm_set ? thread->comm : ""),
1045 thread->pid) > 0)
1046 zoom_thread = nr_options++;
1047
1048 if (dso != NULL &&
1049 asprintf(&options[nr_options], "Zoom %s %s DSO",
1050 (browser->hists->dso_filter ? "out of" : "into"),
1051 (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
1052 zoom_dso = nr_options++;
1053
1054 if (browser->selection != NULL &&
1055 browser->selection->map != NULL &&
1056 asprintf(&options[nr_options], "Browse map details") > 0)
1057 browse_map = nr_options++;
1058 add_exit_option:
1059 options[nr_options++] = (char *)"Exit";
1060 retry_popup_menu:
1061 choice = ui__popup_menu(nr_options, options);
1062
1063 if (choice == nr_options - 1)
1064 break;
1065
1066 if (choice == -1) {
1067 free_popup_options(options, nr_options - 1);
1068 continue;
1069 }
1070
1071 if (choice == annotate || choice == annotate_t || choice == annotate_f) {
1072 struct hist_entry *he;
1073 int err;
1074 do_annotate:
1075 he = hist_browser__selected_entry(browser);
1076 if (he == NULL)
1077 continue;
1078
1079 /*
1080 * we stash the branch_info symbol + map into the
1081 * the ms so we don't have to rewrite all the annotation
1082 * code to use branch_info.
1083 * in branch mode, the ms struct is not used
1084 */
1085 if (choice == annotate_f) {
1086 he->ms.sym = he->branch_info->from.sym;
1087 he->ms.map = he->branch_info->from.map;
1088 } else if (choice == annotate_t) {
1089 he->ms.sym = he->branch_info->to.sym;
1090 he->ms.map = he->branch_info->to.map;
1091 }
1092
1093 /*
1094 * Don't let this be freed, say, by hists__decay_entry.
1095 */
1096 he->used = true;
1097 err = hist_entry__tui_annotate(he, evsel->idx,
1098 timer, arg, delay_secs);
1099 he->used = false;
1100 /*
1101 * offer option to annotate the other branch source or target
1102 * (if they exists) when returning from annotate
1103 */
1104 if ((err == 'q' || err == CTRL('c'))
1105 && annotate_t != -2 && annotate_f != -2)
1106 goto retry_popup_menu;
1107
1108 ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
1109 if (err)
1110 ui_browser__handle_resize(&browser->b);
1111
1112 } else if (choice == browse_map)
1113 map__browse(browser->selection->map);
1114 else if (choice == zoom_dso) {
1115 zoom_dso:
1116 if (browser->hists->dso_filter) {
1117 pstack__remove(fstack, &browser->hists->dso_filter);
1118 zoom_out_dso:
1119 ui_helpline__pop();
1120 browser->hists->dso_filter = NULL;
1121 sort_dso.elide = false;
1122 } else {
1123 if (dso == NULL)
1124 continue;
1125 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
1126 dso->kernel ? "the Kernel" : dso->short_name);
1127 browser->hists->dso_filter = dso;
1128 sort_dso.elide = true;
1129 pstack__push(fstack, &browser->hists->dso_filter);
1130 }
1131 hists__filter_by_dso(hists);
1132 hist_browser__reset(browser);
1133 } else if (choice == zoom_thread) {
1134 zoom_thread:
1135 if (browser->hists->thread_filter) {
1136 pstack__remove(fstack, &browser->hists->thread_filter);
1137 zoom_out_thread:
1138 ui_helpline__pop();
1139 browser->hists->thread_filter = NULL;
1140 sort_thread.elide = false;
1141 } else {
1142 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
1143 thread->comm_set ? thread->comm : "",
1144 thread->pid);
1145 browser->hists->thread_filter = thread;
1146 sort_thread.elide = true;
1147 pstack__push(fstack, &browser->hists->thread_filter);
1148 }
1149 hists__filter_by_thread(hists);
1150 hist_browser__reset(browser);
1151 }
1152 }
1153 out_free_stack:
1154 pstack__delete(fstack);
1155 out:
1156 hist_browser__delete(browser);
1157 free_popup_options(options, nr_options - 1);
1158 return key;
1159 }
1160
1161 struct perf_evsel_menu {
1162 struct ui_browser b;
1163 struct perf_evsel *selection;
1164 bool lost_events, lost_events_warned;
1165 };
1166
1167 static void perf_evsel_menu__write(struct ui_browser *browser,
1168 void *entry, int row)
1169 {
1170 struct perf_evsel_menu *menu = container_of(browser,
1171 struct perf_evsel_menu, b);
1172 struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
1173 bool current_entry = ui_browser__is_current_entry(browser, row);
1174 unsigned long nr_events = evsel->hists.stats.nr_events[PERF_RECORD_SAMPLE];
1175 const char *ev_name = event_name(evsel);
1176 char bf[256], unit;
1177 const char *warn = " ";
1178 size_t printed;
1179
1180 ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
1181 HE_COLORSET_NORMAL);
1182
1183 nr_events = convert_unit(nr_events, &unit);
1184 printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
1185 unit, unit == ' ' ? "" : " ", ev_name);
1186 slsmg_printf("%s", bf);
1187
1188 nr_events = evsel->hists.stats.nr_events[PERF_RECORD_LOST];
1189 if (nr_events != 0) {
1190 menu->lost_events = true;
1191 if (!current_entry)
1192 ui_browser__set_color(browser, HE_COLORSET_TOP);
1193 nr_events = convert_unit(nr_events, &unit);
1194 printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
1195 nr_events, unit, unit == ' ' ? "" : " ");
1196 warn = bf;
1197 }
1198
1199 slsmg_write_nstring(warn, browser->width - printed);
1200
1201 if (current_entry)
1202 menu->selection = evsel;
1203 }
1204
1205 static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
1206 int nr_events, const char *help,
1207 void(*timer)(void *arg), void *arg, int delay_secs)
1208 {
1209 struct perf_evlist *evlist = menu->b.priv;
1210 struct perf_evsel *pos;
1211 const char *ev_name, *title = "Available samples";
1212 int key;
1213
1214 if (ui_browser__show(&menu->b, title,
1215 "ESC: exit, ENTER|->: Browse histograms") < 0)
1216 return -1;
1217
1218 while (1) {
1219 key = ui_browser__run(&menu->b, delay_secs);
1220
1221 switch (key) {
1222 case K_TIMER:
1223 timer(arg);
1224
1225 if (!menu->lost_events_warned && menu->lost_events) {
1226 ui_browser__warn_lost_events(&menu->b);
1227 menu->lost_events_warned = true;
1228 }
1229 continue;
1230 case K_RIGHT:
1231 case K_ENTER:
1232 if (!menu->selection)
1233 continue;
1234 pos = menu->selection;
1235 browse_hists:
1236 perf_evlist__set_selected(evlist, pos);
1237 /*
1238 * Give the calling tool a chance to populate the non
1239 * default evsel resorted hists tree.
1240 */
1241 if (timer)
1242 timer(arg);
1243 ev_name = event_name(pos);
1244 key = perf_evsel__hists_browse(pos, nr_events, help,
1245 ev_name, true, timer,
1246 arg, delay_secs);
1247 ui_browser__show_title(&menu->b, title);
1248 switch (key) {
1249 case K_TAB:
1250 if (pos->node.next == &evlist->entries)
1251 pos = list_entry(evlist->entries.next, struct perf_evsel, node);
1252 else
1253 pos = list_entry(pos->node.next, struct perf_evsel, node);
1254 goto browse_hists;
1255 case K_UNTAB:
1256 if (pos->node.prev == &evlist->entries)
1257 pos = list_entry(evlist->entries.prev, struct perf_evsel, node);
1258 else
1259 pos = list_entry(pos->node.prev, struct perf_evsel, node);
1260 goto browse_hists;
1261 case K_ESC:
1262 if (!ui_browser__dialog_yesno(&menu->b,
1263 "Do you really want to exit?"))
1264 continue;
1265 /* Fall thru */
1266 case 'q':
1267 case CTRL('c'):
1268 goto out;
1269 default:
1270 continue;
1271 }
1272 case K_LEFT:
1273 continue;
1274 case K_ESC:
1275 if (!ui_browser__dialog_yesno(&menu->b,
1276 "Do you really want to exit?"))
1277 continue;
1278 /* Fall thru */
1279 case 'q':
1280 case CTRL('c'):
1281 goto out;
1282 default:
1283 continue;
1284 }
1285 }
1286
1287 out:
1288 ui_browser__hide(&menu->b);
1289 return key;
1290 }
1291
1292 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
1293 const char *help,
1294 void(*timer)(void *arg), void *arg,
1295 int delay_secs)
1296 {
1297 struct perf_evsel *pos;
1298 struct perf_evsel_menu menu = {
1299 .b = {
1300 .entries = &evlist->entries,
1301 .refresh = ui_browser__list_head_refresh,
1302 .seek = ui_browser__list_head_seek,
1303 .write = perf_evsel_menu__write,
1304 .nr_entries = evlist->nr_entries,
1305 .priv = evlist,
1306 },
1307 };
1308
1309 ui_helpline__push("Press ESC to exit");
1310
1311 list_for_each_entry(pos, &evlist->entries, node) {
1312 const char *ev_name = event_name(pos);
1313 size_t line_len = strlen(ev_name) + 7;
1314
1315 if (menu.b.width < line_len)
1316 menu.b.width = line_len;
1317 /*
1318 * Cache the evsel name, tracepoints have a _high_ cost per
1319 * event_name() call.
1320 */
1321 if (pos->name == NULL)
1322 pos->name = strdup(ev_name);
1323 }
1324
1325 return perf_evsel_menu__run(&menu, evlist->nr_entries, help, timer,
1326 arg, delay_secs);
1327 }
1328
1329 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
1330 void(*timer)(void *arg), void *arg,
1331 int delay_secs)
1332 {
1333
1334 if (evlist->nr_entries == 1) {
1335 struct perf_evsel *first = list_entry(evlist->entries.next,
1336 struct perf_evsel, node);
1337 const char *ev_name = event_name(first);
1338 return perf_evsel__hists_browse(first, evlist->nr_entries, help,
1339 ev_name, false, timer, arg,
1340 delay_secs);
1341 }
1342
1343 return __perf_evlist__tui_browse_hists(evlist, help,
1344 timer, arg, delay_secs);
1345 }
Linux kernel - Deliverables
This page took 0.059238 seconds and 5 git commands to generate.