perf tools: Add support for hierachy view (v7)
Namhyung Kim
maintainercover perf tools: Add support for hierachy view (v7)
Hello,
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries belong to an upper-level entry. The entry hierachy is built on the sort keys given, so users can set it whatever they want. It only shows top-level entries first, and user can expand/collapse it dynamically.
* Changes from v6)
- pass srcline, srcfile and trace_output of hist entry properly (Jiri)
- use hist_entry__snprintf_alignment() (Jiri)
* Changes from v5)
- separate resort after filter (Jiri)
- count sort keys when register (Jiri)
- add enum hierarchy_move_dir (Jiri)
* Changes from v4)
- rebased onto the current acme/perf/core
- fix memory leak on callchian_merge error path (Arnaldo)
- fix a bug on perf-top regarding percent calculation
- split hierarchy filtering code
* Changes from v3)
- rebased onto the percent limit patchset v2
* Changes from v2)
- check memory allocation failure in hists__hierarchy_insert_entry (Jiri)
- remove unused rb_hierarchy_first() (Arnaldo)
- support callchain percent limit (Andi)
- break TUI context menu cleanup (Arnaldo)
This time I implemented it for every output browser including TUI. A screenshot on TUI looks like below:
For normal output:
$ perf report --tui
Samples: 3K of event 'cycles:pp', Event count (approx.): 1695979674
Overhead Command Shared Object Symbol
------------------------------------------------------------------------
- 7.57% swapper [kernel.vmlinux] [k] intel_idle
intel_idle
cpuidle_enter_state
cpuidle_enter
call_cpuidle
+ cpu_startup_entry
+ 1.16 firefox firefox [.] 0x00000000000019433
+ 0.97% firefox libpthread-2.22.so [.] pthread_mutex_lock
...With hierarchy view,
$ perf report --tui --hierarchy
Samples: 3K of event 'cycles:pp', Event count (approx.): 1695979674
Overhead Command / Shared Object / Symbol
-------------------------------------------------------------------
+ 76.30% firefox
- 9.95% swapper
- 9.51% [kernel.vmlinux]
- 7.57 [k] intel_idle
intel_idle
cpuidle_enter_state
cpuidle_enter
call_cpuidle
+ cpu_startup_entry
+ 0.15% [k] __schedule
+ 0.12% [k] menu_select
...
+ 0.34% [sdhci]
+ 0.06% [e1000e]
...
+ 5.65% Xorg
+ 5.42% Socket Thread
...As you can see, overhead of an upper level entry is the sum of overhead of lower level entries. The entries are aligned by its order of matching sort keys.
This is available from 'perf/hierarchy-v7' branch in my tree:
git://git.kernel.org/pub/scm/linux/kernel/git/namhyung/linux-perf.git
Any comments are welcome, thanks!
Namhyung
Namhyung Kim (18):
perf tools: Add helper functions for some sort keys perf hists: Basic support of hierarchical report view perf hists: Resort hist entries with hierarchy
perf hists: Add helper functions for hierarchy mode perf hists: Introduce hist_entry__filter()
perf hists: Support filtering in hierarchy mode
perf hists: Resort after filtering hierarchy
perf hists: Count number of sort keys
perf ui/stdio: Implement hierarchy output mode
perf ui/stdio: Align column header for hierarchy output perf hists browser: Count number of hierarchy entries perf hists browser: Support collapsing/expanding whole entries in
hierarchy
perf hists browser: Implement hierarchy output
perf hists browser: Align column header in hierarchy mode perf ui/gtk: Implement hierarchy output mode
perf report: Add --hierarchy option
perf hists: Support decaying in hierarchy mode
perf top: Add --hierarchy option
tools/perf/Documentation/perf-report.txt | 3 + tools/perf/Documentation/perf-top.txt | 3 + tools/perf/Documentation/tips.txt | 1 + tools/perf/builtin-report.c | 17 ++ tools/perf/builtin-top.c | 15 + tools/perf/ui/browsers/hists.c | 504 ++++++++++++++++++++++++++++--- tools/perf/ui/gtk/hists.c | 163 +++++++++- tools/perf/ui/hist.c | 3 + tools/perf/ui/stdio/hist.c | 184 ++++++++++- tools/perf/util/ctype.c | 9 + tools/perf/util/hist.c | 462 ++++++++++++++++++++++++++-- tools/perf/util/hist.h | 24 ++ tools/perf/util/sort.c | 146 +++++++++ tools/perf/util/sort.h | 14 +- tools/perf/util/symbol.h | 3 +- tools/perf/util/util.h | 2 + 16 files changed, 1486 insertions(+), 67 deletions(-)
Signature · 1 line
2.7.1
Namhyung Kim
maintainerPATCH v7 1/18 perf tools: Add helper functions for some sort keys
The trace, srcline and srcfile sort keys updates hist entry's field later. With the hierarchy mode, those fields are passed to a matching entry so it needs to identify the sort keys.
--- tools/perf/util/hist.h | 3 +++ tools/perf/util/sort.c | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+)
tools/perf/util/hist.h +3 -0
@@ -301,6 +301,9 @@ void perf_hpp__append_sort_keys(struct perf_hpp_list *list);bool perf_hpp__is_sort_entry (struct perf_hpp_fmt *format);bool perf_hpp__is_dynamic_entry (struct perf_hpp_fmt *format);bool perf_hpp__defined_dynamic_entry (struct perf_hpp_fmt *fmt,struct hists *hists); +bool perf_hpp__is_trace_entry (struct perf_hpp_fmt *fmt); +bool perf_hpp__is_srcline_entry (struct perf_hpp_fmt *fmt); +bool perf_hpp__is_srcfile_entry (struct perf_hpp_fmt *fmt);static inline bool perf_hpp__should_skip (struct perf_hpp_fmt *format,struct hists *hists)
tools/perf/util/sort.c +33 -0
@@ -1391,6 +1391,39 @@ bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)return format->header == __sort__hpp_header; } +bool perf_hpp__is_trace_entry (struct perf_hpp_fmt *fmt) +{ +struct hpp_sort_entry *hse; + +if (!perf_hpp__is_sort_entry (fmt)) +return false; + + hse = container_of(fmt, struct hpp_sort_entry, hpp); +return hse->se == &sort_trace; +} + +bool perf_hpp__is_srcline_entry (struct perf_hpp_fmt *fmt) +{ +struct hpp_sort_entry *hse; + +if (!perf_hpp__is_sort_entry (fmt)) +return false; + + hse = container_of(fmt, struct hpp_sort_entry, hpp); +return hse->se == &sort_srcline; +} + +bool perf_hpp__is_srcfile_entry (struct perf_hpp_fmt *fmt) +{ +struct hpp_sort_entry *hse; + +if (!perf_hpp__is_sort_entry (fmt)) +return false; + + hse = container_of(fmt, struct hpp_sort_entry, hpp); +return hse->se == &sort_srcfile; +} +static bool __sort__hpp_equal (struct perf_hpp_fmt *a,struct perf_hpp_fmt *b) {struct hpp_sort_entry *hse_a;
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf tools: Add helper functions for some sort keys
perf tools: Add helper functions for some sort keys
Commit-ID: a9c6e46c04ba38925e94c4c2fa9217460338db43 Gitweb: http://git.kernel.org/tip/a9c6e46c04ba38925e94c4c2fa9217460338db43 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:33 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 13:05:04 -0300
perf tools: Add helper functions for some sort keys
The 'trace', 'srcline' and 'srcfile' sort keys updates hist entry's field later. With the hierarchy mode, those fields are passed to a matching entry so it needs to identify the sort keys.
--- tools/perf/util/hist.h | 3 +++ tools/perf/util/sort.c | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+)
tools/perf/util/hist.h +3 -0
@@ -301,6 +301,9 @@ void perf_hpp__append_sort_keys(struct perf_hpp_list *list);bool perf_hpp__is_sort_entry (struct perf_hpp_fmt *format);bool perf_hpp__is_dynamic_entry (struct perf_hpp_fmt *format);bool perf_hpp__defined_dynamic_entry (struct perf_hpp_fmt *fmt,struct hists *hists); +bool perf_hpp__is_trace_entry (struct perf_hpp_fmt *fmt); +bool perf_hpp__is_srcline_entry (struct perf_hpp_fmt *fmt); +bool perf_hpp__is_srcfile_entry (struct perf_hpp_fmt *fmt);static inline bool perf_hpp__should_skip (struct perf_hpp_fmt *format,struct hists *hists)
tools/perf/util/sort.c +33 -0
@@ -1391,6 +1391,39 @@ bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)return format->header == __sort__hpp_header; } +bool perf_hpp__is_trace_entry (struct perf_hpp_fmt *fmt) +{ +struct hpp_sort_entry *hse; + +if (!perf_hpp__is_sort_entry (fmt)) +return false; + + hse = container_of(fmt, struct hpp_sort_entry, hpp); +return hse->se == &sort_trace; +} + +bool perf_hpp__is_srcline_entry (struct perf_hpp_fmt *fmt) +{ +struct hpp_sort_entry *hse; + +if (!perf_hpp__is_sort_entry (fmt)) +return false; + + hse = container_of(fmt, struct hpp_sort_entry, hpp); +return hse->se == &sort_srcline; +} + +bool perf_hpp__is_srcfile_entry (struct perf_hpp_fmt *fmt) +{ +struct hpp_sort_entry *hse; + +if (!perf_hpp__is_sort_entry (fmt)) +return false; + + hse = container_of(fmt, struct hpp_sort_entry, hpp); +return hse->se == &sort_srcfile; +} +static bool __sort__hpp_equal (struct perf_hpp_fmt *a,struct perf_hpp_fmt *b) {struct hpp_sort_entry *hse_a;
Namhyung Kim
maintainerPATCH v7 2/18 perf hists: Basic support of hierarchical report view
In reply to Namhyung KimIn the hierarchical view, entries will be grouped and sorted on the first key, and then second key, and so on. Add he->hroot_{in,out} field to keep lower level entries. Actually this can be shared with callchain sorted_root since the hroots are only used by non-leaf entries and callchain is only used by leaf entries.
It also adds parent_he and depth fields which can be used by browsers.
This patch only implements collapsing part which creates internal entries for each sort key. These need to be sorted by output_sort stage and to be displayed properly in the later patch(es).
--- tools/perf/util/hist.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/sort.h | 13 +++++- tools/perf/util/symbol.h | 3 +- 3 files changed, 128 insertions(+), 2 deletions(-)
tools/perf/util/hist.c +114 -0
@@ -396,6 +396,9 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template, }INIT_LIST_HEAD (&he->pairs.node);thread__get (he->thread); + +if (!symbol_conf.report_hierarchy) + he->leaf = true; }return he;
@@ -1049,6 +1052,114 @@ int hist_entry__snprintf_alignment(struct hist_entry *he, struct perf_hpp *hpp,* collapse the histogram */ +static void hists__apply_filters (struct hists *hists,struct hist_entry *he); + +static struct hist_entry *hierarchy_insert_entry (struct hists *hists, +struct rb_root *root, +struct hist_entry *he, +struct perf_hpp_fmt *fmt) +{ +struct rb_node **p = &root->rb_node; +struct rb_node *parent =NULL ; +struct hist_entry *iter, *new; +int64_t cmp; + +while (*p !=NULL ) { + parent = *p; + iter = rb_entry(parent, struct hist_entry, rb_node_in); + + cmp = fmt->collapse (fmt, iter, he); +if (!cmp) { +he_stat__add_stat (&iter->stat, &he->stat); +return iter; + } + +if (cmp <0 ) + p = &parent->rb_left; +else + p = &parent->rb_right; + } + + new =hist_entry__new (he, true); +if (new ==NULL ) +return NULL ; + +hists__apply_filters (hists, new); + hists->nr_entries++; + +/* save related format for output */ + new->fmt = fmt; + +/* some fields are now passed to 'new' */ +if (perf_hpp__is_trace_entry (fmt)) + he->trace_output =NULL ; +else + new->trace_output =NULL ; + +if (perf_hpp__is_srcline_entry (fmt)) + he->srcline =NULL ; +else + new->srcline =NULL ; + +if (perf_hpp__is_srcfile_entry (fmt)) + he->srcfile =NULL ; +else + new->srcfile =NULL ; + +rb_link_node (&new->rb_node_in, parent, p); +rb_insert_color (&new->rb_node_in, root); +return new; +} + +static int hists__hierarchy_insert_entry (struct hists *hists, +struct rb_root *root, +struct hist_entry *he) +{ +struct perf_hpp_fmt *fmt; +struct hist_entry *new_he =NULL ; +struct hist_entry *parent =NULL ; +int depth =0 ; +int ret =0 ; + +hists__for_each_sort_list (hists, fmt) { +if (!perf_hpp__is_sort_entry (fmt) && + !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + +/* insert copy of 'he' for each fmt into the hierarchy */ + new_he =hierarchy_insert_entry (hists, root, he, fmt); +if (new_he ==NULL ) { + ret =-1 ; +break ; + } + + root = &new_he->hroot_in; + new_he->parent_he = parent; + new_he->depth = depth++; + parent = new_he; + } + +if (new_he) { + new_he->leaf = true; + +if (symbol_conf.use_callchain) { +callchain_cursor_reset (&callchain_cursor); +if (callchain_merge (&callchain_cursor, + new_he->callchain, + he->callchain) <0 ) + ret =-1 ; + } + } + +/* 'he' is no longer used */ +hist_entry__delete (he); + +/* return 0 (or -1) since it already applied filters */ +return ret; +} +int hists__collapse_insert_entry (struct hists *hists,struct rb_root *root,struct hist_entry *he) {
@@ -1057,6 +1168,9 @@ int hists__collapse_insert_entry(struct hists *hists, struct rb_root *root,struct hist_entry *iter;int64_t cmp; +if (symbol_conf.report_hierarchy) +return hists__hierarchy_insert_entry (hists, root, he); +while (*p !=NULL ) { parent = *p; iter = rb_entry(parent, struct hist_entry, rb_node_in);
tools/perf/util/sort.h +12 -1
@@ -96,9 +96,11 @@ struct hist_entry {s32 socket;s32 cpu;u8 cpumode; +u8 depth;/* We are added by hists__add_dummy_entry. */ bool dummy; +bool leaf;char level;u8 filtered;
@@ -120,13 +122,22 @@ struct hist_entry {char *srcline;char *srcfile;struct symbol *parent; -struct rb_root sorted_chain;struct branch_info *branch_info;struct hists *hists;struct mem_info *mem_info;void *raw_data;u32 raw_size;void *trace_output; +struct perf_hpp_fmt *fmt; +struct hist_entry *parent_he; +union { +/* this is for hierarchical entry structure */ +struct { +struct rb_root hroot_in; +struct rb_root hroot_out; + };/* non-leaf entries */ +struct rb_root sorted_chain;/* leaf entry has callchains */ + };struct callchain_root callchain[0 ];/* must be last member */ };
tools/perf/util/symbol.h +2 -1
@@ -110,7 +110,8 @@ struct symbol_conf { has_filter, show_ref_callgraph, hide_unresolved, - raw_trace; + raw_trace, + report_hierarchy;const char *vmlinux_name, *kallsyms_name, *source_prefix,
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists: Basic support of hierarchical report view
perf hists: Basic support of hierarchical report view
Commit-ID: aef810ec4e6b638facb6c81803c019906f34f014 Gitweb: http://git.kernel.org/tip/aef810ec4e6b638facb6c81803c019906f34f014 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:34 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 13:35:44 -0300
perf hists: Basic support of hierarchical report view
In the hierarchical view, entries will be grouped and sorted on the first key, and then on the second key, and so on. Add the he->hroot_{in,out} fields to keep the lower level entries. Actually this can share space, in a union, with callchain's 'sorted_root' since the hroots are only used by non-leaf entries and callchain is only used by leaf entries.
It also adds the 'parent_he' and 'depth' fields which can be used by browsers.
This patch only implements collapsing part which creates internal entries for each sort key. These need to be sorted by output_sort stage and to be displayed properly in the later patch(es).
--- tools/perf/util/hist.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/sort.h | 13 +++++- tools/perf/util/symbol.h | 3 +- 3 files changed, 128 insertions(+), 2 deletions(-)
tools/perf/util/hist.c +114 -0
@@ -396,6 +396,9 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template, }INIT_LIST_HEAD (&he->pairs.node);thread__get (he->thread); + +if (!symbol_conf.report_hierarchy) + he->leaf = true; }return he;
@@ -1049,6 +1052,114 @@ int hist_entry__snprintf_alignment(struct hist_entry *he, struct perf_hpp *hpp,* collapse the histogram */ +static void hists__apply_filters (struct hists *hists,struct hist_entry *he); + +static struct hist_entry *hierarchy_insert_entry (struct hists *hists, +struct rb_root *root, +struct hist_entry *he, +struct perf_hpp_fmt *fmt) +{ +struct rb_node **p = &root->rb_node; +struct rb_node *parent =NULL ; +struct hist_entry *iter, *new; +int64_t cmp; + +while (*p !=NULL ) { + parent = *p; + iter = rb_entry(parent, struct hist_entry, rb_node_in); + + cmp = fmt->collapse (fmt, iter, he); +if (!cmp) { +he_stat__add_stat (&iter->stat, &he->stat); +return iter; + } + +if (cmp <0 ) + p = &parent->rb_left; +else + p = &parent->rb_right; + } + + new =hist_entry__new (he, true); +if (new ==NULL ) +return NULL ; + +hists__apply_filters (hists, new); + hists->nr_entries++; + +/* save related format for output */ + new->fmt = fmt; + +/* some fields are now passed to 'new' */ +if (perf_hpp__is_trace_entry (fmt)) + he->trace_output =NULL ; +else + new->trace_output =NULL ; + +if (perf_hpp__is_srcline_entry (fmt)) + he->srcline =NULL ; +else + new->srcline =NULL ; + +if (perf_hpp__is_srcfile_entry (fmt)) + he->srcfile =NULL ; +else + new->srcfile =NULL ; + +rb_link_node (&new->rb_node_in, parent, p); +rb_insert_color (&new->rb_node_in, root); +return new; +} + +static int hists__hierarchy_insert_entry (struct hists *hists, +struct rb_root *root, +struct hist_entry *he) +{ +struct perf_hpp_fmt *fmt; +struct hist_entry *new_he =NULL ; +struct hist_entry *parent =NULL ; +int depth =0 ; +int ret =0 ; + +hists__for_each_sort_list (hists, fmt) { +if (!perf_hpp__is_sort_entry (fmt) && + !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + +/* insert copy of 'he' for each fmt into the hierarchy */ + new_he =hierarchy_insert_entry (hists, root, he, fmt); +if (new_he ==NULL ) { + ret =-1 ; +break ; + } + + root = &new_he->hroot_in; + new_he->parent_he = parent; + new_he->depth = depth++; + parent = new_he; + } + +if (new_he) { + new_he->leaf = true; + +if (symbol_conf.use_callchain) { +callchain_cursor_reset (&callchain_cursor); +if (callchain_merge (&callchain_cursor, + new_he->callchain, + he->callchain) <0 ) + ret =-1 ; + } + } + +/* 'he' is no longer used */ +hist_entry__delete (he); + +/* return 0 (or -1) since it already applied filters */ +return ret; +} +int hists__collapse_insert_entry (struct hists *hists,struct rb_root *root,struct hist_entry *he) {
@@ -1057,6 +1168,9 @@ int hists__collapse_insert_entry(struct hists *hists, struct rb_root *root,struct hist_entry *iter;int64_t cmp; +if (symbol_conf.report_hierarchy) +return hists__hierarchy_insert_entry (hists, root, he); +while (*p !=NULL ) { parent = *p; iter = rb_entry(parent, struct hist_entry, rb_node_in);
tools/perf/util/sort.h +12 -1
@@ -96,9 +96,11 @@ struct hist_entry {s32 socket;s32 cpu;u8 cpumode; +u8 depth;/* We are added by hists__add_dummy_entry. */ bool dummy; +bool leaf;char level;u8 filtered;
@@ -120,13 +122,22 @@ struct hist_entry {char *srcline;char *srcfile;struct symbol *parent; -struct rb_root sorted_chain;struct branch_info *branch_info;struct hists *hists;struct mem_info *mem_info;void *raw_data;u32 raw_size;void *trace_output; +struct perf_hpp_fmt *fmt; +struct hist_entry *parent_he; +union { +/* this is for hierarchical entry structure */ +struct { +struct rb_root hroot_in; +struct rb_root hroot_out; + };/* non-leaf entries */ +struct rb_root sorted_chain;/* leaf entry has callchains */ + };struct callchain_root callchain[0 ];/* must be last member */ };
tools/perf/util/symbol.h +2 -1
@@ -110,7 +110,8 @@ struct symbol_conf { has_filter, show_ref_callgraph, hide_unresolved, - raw_trace; + raw_trace, + report_hierarchy;const char *vmlinux_name, *kallsyms_name, *source_prefix,
Namhyung Kim
maintainerPATCH v7 3/18 perf hists: Resort hist entries with hierarchy
In reply to Namhyung KimFor hierarchical output, each entries should be sorted in their rbtree (hroot) properly. Add hists__hierarchy_output_resort() to do the job. Note that those hierarchy entries share the period counts, it'd be important to update the hists->stats only once (for leaves).
--- tools/perf/util/hist.c | 94 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 91 insertions(+), 3 deletions(-)
tools/perf/util/hist.c +91 -3
@@ -1318,6 +1318,86 @@ void hists__inc_stats(struct hists *hists, struct hist_entry *h) hists->stats.total_period += h->stat.period; } +static void hierarchy_insert_output_entry (struct rb_root *root, +struct hist_entry *he) +{ +struct rb_node **p = &root->rb_node; +struct rb_node *parent =NULL ; +struct hist_entry *iter; + +while (*p !=NULL ) { + parent = *p; + iter = rb_entry(parent, struct hist_entry, rb_node); + +if (hist_entry__sort (he, iter) >0 ) + p = &parent->rb_left; +else + p = &parent->rb_right; + } + +rb_link_node (&he->rb_node, parent, p); +rb_insert_color (&he->rb_node, root); +} + +static void hists__hierarchy_output_resort (struct hists *hists, +struct ui_progress *prog, +struct rb_root *root_in, +struct rb_root *root_out, +u64 min_callchain_hits, +bool use_callchain) +{ +struct rb_node *node; +struct hist_entry *he; + + *root_out =RB_ROOT ; + node =rb_first (root_in); + +while (node) { + he = rb_entry(node, struct hist_entry, rb_node_in); + node =rb_next (node); + +hierarchy_insert_output_entry (root_out, he); + +if (prog) +ui_progress__update (prog,1 ); + +if (!he->leaf) { +hists__hierarchy_output_resort (hists, prog, + &he->hroot_in, + &he->hroot_out, + min_callchain_hits, + use_callchain); + hists->nr_entries++; +if (!he->filtered) { + hists->nr_non_filtered_entries++; +hists__calc_col_len (hists, he); + } + +continue ; + } + +/* only update stat for leaf entries to avoid duplication */ +hists__inc_stats (hists, he); +if (!he->filtered) +hists__calc_col_len (hists, he); + +if (!use_callchain) +continue ; + +if (callchain_param.mode ==CHAIN_GRAPH_REL ) { +u64 total = he->stat.period; + +if (symbol_conf.cumulate_callchain) + total = he->stat_acc->period; + + min_callchain_hits = total * (callchain_param.min_percent /100 ); + } + + callchain_param.sort (&he->sorted_chain, he->callchain, + min_callchain_hits, &callchain_param); + } +} + static void __hists__insert_output_entry(struct rb_root *entries, struct hist_entry *he, u64 min_callchain_hits,
@@ -1369,6 +1449,17 @@ static void output_resort(struct hists *hists, struct ui_progress *prog, min_callchain_hits = callchain_total * (callchain_param.min_percent /100 ); +hists__reset_stats (hists); +hists__reset_col_len (hists); + +if (symbol_conf.report_hierarchy) { +return hists__hierarchy_output_resort (hists, prog, + &hists->entries_collapsed, + &hists->entries, + min_callchain_hits, + use_callchain); + } +if (sort__need_collapse) root = &hists->entries_collapsed;else
@@ -1377,9 +1468,6 @@ static void output_resort(struct hists *hists, struct ui_progress *prog, next =rb_first (root); hists->entries =RB_ROOT ; -hists__reset_stats (hists); -hists__reset_col_len (hists); -while (next) { n = rb_entry(next, struct hist_entry, rb_node_in); next =rb_next (&n->rb_node_in);
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists: Resort hist entries with hierarchy
perf hists: Resort hist entries with hierarchy
Commit-ID: 1a3906a7e6b9cbfaf2a3d00c310aed8af8e10d92 Gitweb: http://git.kernel.org/tip/1a3906a7e6b9cbfaf2a3d00c310aed8af8e10d92 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:35 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 16:54:09 -0300
perf hists: Resort hist entries with hierarchy
For hierarchical output, each entry must be sorted in their rbtree (hroot) properly. Add hists__hierarchy_output_resort() to do the job. Note that those hierarchy entries share the period counts, it'd be important to update the hists->stats only once (for leaves).
--- tools/perf/util/hist.c | 94 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 91 insertions(+), 3 deletions(-)
tools/perf/util/hist.c +91 -3
@@ -1318,6 +1318,86 @@ void hists__inc_stats(struct hists *hists, struct hist_entry *h) hists->stats.total_period += h->stat.period; } +static void hierarchy_insert_output_entry (struct rb_root *root, +struct hist_entry *he) +{ +struct rb_node **p = &root->rb_node; +struct rb_node *parent =NULL ; +struct hist_entry *iter; + +while (*p !=NULL ) { + parent = *p; + iter = rb_entry(parent, struct hist_entry, rb_node); + +if (hist_entry__sort (he, iter) >0 ) + p = &parent->rb_left; +else + p = &parent->rb_right; + } + +rb_link_node (&he->rb_node, parent, p); +rb_insert_color (&he->rb_node, root); +} + +static void hists__hierarchy_output_resort (struct hists *hists, +struct ui_progress *prog, +struct rb_root *root_in, +struct rb_root *root_out, +u64 min_callchain_hits, +bool use_callchain) +{ +struct rb_node *node; +struct hist_entry *he; + + *root_out =RB_ROOT ; + node =rb_first (root_in); + +while (node) { + he = rb_entry(node, struct hist_entry, rb_node_in); + node =rb_next (node); + +hierarchy_insert_output_entry (root_out, he); + +if (prog) +ui_progress__update (prog,1 ); + +if (!he->leaf) { +hists__hierarchy_output_resort (hists, prog, + &he->hroot_in, + &he->hroot_out, + min_callchain_hits, + use_callchain); + hists->nr_entries++; +if (!he->filtered) { + hists->nr_non_filtered_entries++; +hists__calc_col_len (hists, he); + } + +continue ; + } + +/* only update stat for leaf entries to avoid duplication */ +hists__inc_stats (hists, he); +if (!he->filtered) +hists__calc_col_len (hists, he); + +if (!use_callchain) +continue ; + +if (callchain_param.mode ==CHAIN_GRAPH_REL ) { +u64 total = he->stat.period; + +if (symbol_conf.cumulate_callchain) + total = he->stat_acc->period; + + min_callchain_hits = total * (callchain_param.min_percent /100 ); + } + + callchain_param.sort (&he->sorted_chain, he->callchain, + min_callchain_hits, &callchain_param); + } +} + static void __hists__insert_output_entry(struct rb_root *entries, struct hist_entry *he, u64 min_callchain_hits,
@@ -1369,6 +1449,17 @@ static void output_resort(struct hists *hists, struct ui_progress *prog, min_callchain_hits = callchain_total * (callchain_param.min_percent /100 ); +hists__reset_stats (hists); +hists__reset_col_len (hists); + +if (symbol_conf.report_hierarchy) { +return hists__hierarchy_output_resort (hists, prog, + &hists->entries_collapsed, + &hists->entries, + min_callchain_hits, + use_callchain); + } +if (sort__need_collapse) root = &hists->entries_collapsed;else
@@ -1377,9 +1468,6 @@ static void output_resort(struct hists *hists, struct ui_progress *prog, next =rb_first (root); hists->entries =RB_ROOT ; -hists__reset_stats (hists); -hists__reset_col_len (hists); -while (next) { n = rb_entry(next, struct hist_entry, rb_node_in); next =rb_next (&n->rb_node_in);
Namhyung Kim
maintainerPATCH v7 4/18 perf hists: Add helper functions for hierarchy mode
In reply to Namhyung KimThe rb_hierarchy_{next,prev,last} functions are to traverse all hist entries in a hierarchy. They will be used by various function which supports hierarchy output.
As the rb_hierarchy_next() is used to traverse the whole hierarchy, it sometime needs to visit entries regardless of current folding state. So add enum hierarchy_move_dir and pass it to __rb_hierarchy_next() for those cases.
--- tools/perf/util/hist.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/hist.h | 16 ++++++++++++++ 2 files changed, 73 insertions(+)
tools/perf/util/hist.c +57 -0
@@ -1483,6 +1483,7 @@ static void output_resort(struct hists *hists, struct ui_progress *prog, } } +void perf_evsel__output_resort (struct perf_evsel *evsel,struct ui_progress *prog) {bool use_callchain;
@@ -1500,6 +1501,62 @@ void hists__output_resort(struct hists *hists, struct ui_progress *prog)output_resort (hists, prog, symbol_conf.use_callchain); } +static bool can_goto_child (struct hist_entry *he,enum hierarchy_move_dir hmd) +{ +if (he->leaf || hmd ==HMD_FORCE_SIBLING ) +return false; + +if (he->unfolded || hmd ==HMD_FORCE_CHILD ) +return true; + +return false; +} + +struct rb_node *rb_hierarchy_last (struct rb_node *node) +{ + struct hist_entry *he = rb_entry(node, struct hist_entry, rb_node); + +while (can_goto_child (he,HMD_NORMAL )) { + node =rb_last (&he->hroot_out); + he = rb_entry(node, struct hist_entry, rb_node); + } +return node; +} + +struct rb_node *__rb_hierarchy_next (struct rb_node *node,enum hierarchy_move_dir hmd) +{ + struct hist_entry *he = rb_entry(node, struct hist_entry, rb_node); + +if (can_goto_child (he, hmd)) + node =rb_first (&he->hroot_out); +else + node =rb_next (node); + +while (node ==NULL ) { + he = he->parent_he; +if (he ==NULL ) +break ; + + node =rb_next (&he->rb_node); + } +return node; +} + +struct rb_node *rb_hierarchy_prev (struct rb_node *node) +{ + struct hist_entry *he = rb_entry(node, struct hist_entry, rb_node); + + node =rb_prev (node); +if (node) +return rb_hierarchy_last (node); + + he = he->parent_he; +if (he ==NULL ) +return NULL ; + +return &he->rb_node; +} +static void hists__remove_entry_filter (struct hists *hists,struct hist_entry *h,enum hist_filter filter) {
tools/perf/util/hist.h +16 -0
@@ -418,4 +418,20 @@ int perf_hist_config(const char *var, const char *value);void perf_hpp_list__init (struct perf_hpp_list *list); +enum hierarchy_move_dir { +HMD_NORMAL , +HMD_FORCE_SIBLING , +HMD_FORCE_CHILD , +}; + +struct rb_node *rb_hierarchy_last (struct rb_node *node); +struct rb_node *__rb_hierarchy_next (struct rb_node *node, +enum hierarchy_move_dir hmd); +struct rb_node *rb_hierarchy_prev (struct rb_node *node); + +static inline struct rb_node *rb_hierarchy_next (struct rb_node *node) +{ +return __rb_hierarchy_next (node,HMD_NORMAL ); +} +#endif /* __PERF_HIST_H */
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists: Add helper functions for hierarchy mode
perf hists: Add helper functions for hierarchy mode
Commit-ID: 8c01872fe3c17fde1ce74eecf523d6d7fce5ffec Gitweb: http://git.kernel.org/tip/8c01872fe3c17fde1ce74eecf523d6d7fce5ffec Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:36 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 16:55:17 -0300
perf hists: Add helper functions for hierarchy mode
The rb_hierarchy_{next,prev,last} functions are to traverse all hist entries in a hierarchy. They will be used by various function which supports hierarchy output.
As the rb_hierarchy_next() is used to traverse the whole hierarchy, it sometime needs to visit entries regardless of current folding state. So add enum hierarchy_move_dir and pass it to __rb_hierarchy_next() for those cases.
--- tools/perf/util/hist.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/hist.h | 16 +++++++++++++++ 2 files changed, 72 insertions(+)
tools/perf/util/hist.c +56 -0
@@ -1500,6 +1500,62 @@ void hists__output_resort(struct hists *hists, struct ui_progress *prog)output_resort (hists, prog, symbol_conf.use_callchain); } +static bool can_goto_child (struct hist_entry *he,enum hierarchy_move_dir hmd) +{ +if (he->leaf || hmd ==HMD_FORCE_SIBLING ) +return false; + +if (he->unfolded || hmd ==HMD_FORCE_CHILD ) +return true; + +return false; +} + +struct rb_node *rb_hierarchy_last (struct rb_node *node) +{ + struct hist_entry *he = rb_entry(node, struct hist_entry, rb_node); + +while (can_goto_child (he,HMD_NORMAL )) { + node =rb_last (&he->hroot_out); + he = rb_entry(node, struct hist_entry, rb_node); + } +return node; +} + +struct rb_node *__rb_hierarchy_next (struct rb_node *node,enum hierarchy_move_dir hmd) +{ + struct hist_entry *he = rb_entry(node, struct hist_entry, rb_node); + +if (can_goto_child (he, hmd)) + node =rb_first (&he->hroot_out); +else + node =rb_next (node); + +while (node ==NULL ) { + he = he->parent_he; +if (he ==NULL ) +break ; + + node =rb_next (&he->rb_node); + } +return node; +} + +struct rb_node *rb_hierarchy_prev (struct rb_node *node) +{ + struct hist_entry *he = rb_entry(node, struct hist_entry, rb_node); + + node =rb_prev (node); +if (node) +return rb_hierarchy_last (node); + + he = he->parent_he; +if (he ==NULL ) +return NULL ; + +return &he->rb_node; +} +static void hists__remove_entry_filter (struct hists *hists,struct hist_entry *h,enum hist_filter filter) {
tools/perf/util/hist.h +16 -0
@@ -418,4 +418,20 @@ int perf_hist_config(const char *var, const char *value);void perf_hpp_list__init (struct perf_hpp_list *list); +enum hierarchy_move_dir { +HMD_NORMAL , +HMD_FORCE_SIBLING , +HMD_FORCE_CHILD , +}; + +struct rb_node *rb_hierarchy_last (struct rb_node *node); +struct rb_node *__rb_hierarchy_next (struct rb_node *node, +enum hierarchy_move_dir hmd); +struct rb_node *rb_hierarchy_prev (struct rb_node *node); + +static inline struct rb_node *rb_hierarchy_next (struct rb_node *node) +{ +return __rb_hierarchy_next (node,HMD_NORMAL ); +} +#endif /* __PERF_HIST_H */
Namhyung Kim
maintainerPATCH v7 5/18 perf hists: Introduce hist_entry__filter()
In reply to Namhyung KimThe hist_entry__filter() function is to filter hist entries using sort key relatd info. This is needed to support hierarchy mode since each hist entry will be associated with a hpp fmt which has a sort key. So each entry should compare to only matching type of filters.
To do that, add the ->se_filter callback field to struct sort_entry. This callback takes 'type' argument which determines whether it's matching sort key or not. It returns -1 for non-matching type, 0 for filtered entry and 1 for not filtered entries.
--- tools/perf/util/hist.h | 2 + tools/perf/util/sort.c | 113 +++++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/sort.h | 1 + 3 files changed, 116 insertions(+)
tools/perf/util/hist.h +2 -0
@@ -305,6 +305,8 @@ bool perf_hpp__is_trace_entry(struct perf_hpp_fmt *fmt);bool perf_hpp__is_srcline_entry (struct perf_hpp_fmt *fmt);bool perf_hpp__is_srcfile_entry (struct perf_hpp_fmt *fmt); +int hist_entry__filter (struct hist_entry *he,int type,const void *arg); +static inline bool perf_hpp__should_skip (struct perf_hpp_fmt *format,struct hists *hists) {
tools/perf/util/sort.c +113 -0
206 lines not on this page · raw message
tools/perf/util/sort.h +1 -0
@@ -245,6 +245,7 @@ struct sort_entry {int64_t (*se_sort)(struct hist_entry *,struct hist_entry *);int (*se_snprintf)(struct hist_entry *he,char *bf,size_t size,unsigned int width); +int (*se_filter)(struct hist_entry *he,int type,const void *arg);u8 se_width_idx; };
Signature · 1 line
2.7.1
Arnaldo Carvalho de Melo
maintainerRe: [PATCH v7 05/18] perf hists: Introduce hist_entry__filter()
Em Thu, Feb 25, 2016 at 12:13:37AM +0900, Namhyung Kim escreveu:
tools/perf/util/sort.c static int hist_entry__socket_snprintf(struct hist_entry *he, char *bf, · line 484
Quoted 8 lines
tools/perf/util/sort.c +8
-0+static int hist_entry__socket_filter (struct hist_entry *he,int type,const void *arg) +{ +int socket = *(const int *)arg; + +if (type !=HIST_FILTER__SOCKET ) +return -1 ; + +return socket >=0 && he->socket != socket;
'socket' is a function in sys/socket.h, and in older systems this file, tools/perf/util/sort.c, ends up including that header, causing:
CC /tmp/build/perf/util/sort.o
cc1: warnings being treated as errorsutil/sort.c: In function ‘hist_entry__socket_filter’:util/sort.c:479: error: declaration of ‘socket’ shadows a global declaration/usr/include/sys/socket.h:105: error: shadowed declaration is here
I fixed it renaming it to 'sk'.
- Arnaldo
Namhyung Kim
maintainerRe: [PATCH v7 05/18] perf hists: Introduce hist_entry__filter()
Hi Arnaldo,
Quoted 13 lines · Arnaldo Carvalho de Melo
Em Thu, Feb 25, 2016 at 12:13:37AM +0900, Namhyung Kim escreveu:
tools/perf/util/sort.c static int hist_entry__socket_snprintf(struct hist_entry *he, char *bf, · line 484
Quoted 8 lines
tools/perf/util/sort.c +8
-0+static int hist_entry__socket_filter (struct hist_entry *he,int type,const void *arg) +{ +int socket = *(const int *)arg; + +if (type !=HIST_FILTER__SOCKET ) +return -1 ; + +return socket >=0 && he->socket != socket;'socket' is a function in
sys/socket.h, and in older systems this file,tools/perf/util/sort.c, ends up including that header, causing:
Quoted 8 lines
CC
/tmp/build/perf/util/sort.o
cc1: warnings being treated as errorsutil/sort.c: In function ‘hist_entry__socket_filter’:util/sort.c:479: error: declaration of ‘socket’ shadows a global declaration/usr/include/sys/socket.h:105: error: shadowed declaration is hereI fixed it renaming it to 'sk'.
Oh, thank you for fixing this!
Thanks,
Namhyung
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists: Introduce hist_entry__filter()
In reply to Namhyung Kimperf hists: Introduce hist_entry__filter()
Commit-ID: 54430101d2af260dba2d129cc9d9b7c7e60087b0 Gitweb: http://git.kernel.org/tip/54430101d2af260dba2d129cc9d9b7c7e60087b0 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:37 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:19:14 -0300
perf hists: Introduce hist_entry__filter()
The hist_entry__filter() function is to filter hist entries using sort key related info. This is needed to support hierarchy mode since each hist entry will be associated with a hpp fmt which has a sort key. So each entry should compare to only matching type of filters.
To do that, add the ->se_filter callback field to struct sort_entry. This callback takes 'type' argument which determines whether it's matching sort key or not. It returns -1 for non-matching type, 0 for filtered entry and 1 for not filtered entries.
--- tools/perf/util/hist.h | 2 + tools/perf/util/sort.c | 113 +++++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/sort.h | 1 + 3 files changed, 116 insertions(+)
tools/perf/util/hist.h +2 -0
@@ -305,6 +305,8 @@ bool perf_hpp__is_trace_entry(struct perf_hpp_fmt *fmt);bool perf_hpp__is_srcline_entry (struct perf_hpp_fmt *fmt);bool perf_hpp__is_srcfile_entry (struct perf_hpp_fmt *fmt); +int hist_entry__filter (struct hist_entry *he,int type,const void *arg); +static inline bool perf_hpp__should_skip (struct perf_hpp_fmt *format,struct hists *hists) {
tools/perf/util/sort.c +113 -0
206 lines not on this page · raw message
tools/perf/util/sort.h +1 -0
@@ -245,6 +245,7 @@ struct sort_entry {int64_t (*se_sort)(struct hist_entry *,struct hist_entry *);int (*se_snprintf)(struct hist_entry *he,char *bf,size_t size,unsigned int width); +int (*se_filter)(struct hist_entry *he,int type,const void *arg);u8 se_width_idx; };
Namhyung Kim
maintainerPATCH v7 6/18 perf hists: Support filtering in hierarchy mode
In reply to Namhyung KimThe hists__filter_hierarchy() function implements filtering in hierarchy mode. Now we have hist_entry__filter() so use it for entries in the hierarchy. It returns 3 kind of values.
A negative value means that it's not filtered by this type. It marks current entry as filtered tentatively so if a lower level entry removes the filter it also removes the all parent so that we can find the entry in the output.
Zero means it's filtered out by this type. A positive value means it's not filtered so it removes the filter and shows in the output. In these cases, it moves to next entry since lower level entry won't match by this type of filter anymore. Thus all children will be filtered or not together.
--- tools/perf/util/hist.c | 101 +++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 93 insertions(+), 8 deletions(-)
tools/perf/util/hist.c +93 -8
@@ -1561,6 +1561,27 @@ static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h enum hist_filter filter) { h->filtered &= ~(1 << filter); + +if (symbol_conf.report_hierarchy) { +struct hist_entry *parent = h->parent_he; + +while (parent) { +he_stat__add_stat (&parent->stat, &h->stat); + + parent->filtered &= ~(1 << filter); + +if (parent->filtered) + goto next; + +/* force fold unfiltered entry for simplicity */ + parent->unfolded = false; + parent->row_offset =0 ; + parent->nr_rows =0 ; +next: + parent = parent->parent_he; + } + } +if (h->filtered)return ;
@@ -1646,28 +1667,92 @@ static void hists__filter_by_type(struct hists *hists, int type, filter_fn_t fil } } +static void hists__filter_hierarchy (struct hists *hists,int type,const void *arg) +{ +struct rb_node *nd; + + hists->stats.nr_non_filtered_samples =0 ; + +hists__reset_filter_stats (hists); +hists__reset_col_len (hists); + + nd =rb_first (&hists->entries); +while (nd) { + struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); +int ret; + + ret =hist_entry__filter (h, type, arg); + +/* +* case 1. non-matching type +* zero out the period, set filter marker and move to child +*/ +if (ret <0 ) { +memset (&h->stat,0 ,sizeof (h->stat)); + h->filtered |= (1 << type); + + nd =__rb_hierarchy_next (&h->rb_node,HMD_FORCE_CHILD ); + } +/* +* case 2. matched type (filter out) +* set filter marker and move to next +*/ +else if (ret ==1 ) { + h->filtered |= (1 << type); + + nd =__rb_hierarchy_next (&h->rb_node,HMD_FORCE_SIBLING ); + } +/* +* case 3. ok (not filtered) +* add period to hists and parents, erase the filter marker +* and move to next sibling +*/ +else { +hists__remove_entry_filter (hists, h, type); + + nd =__rb_hierarchy_next (&h->rb_node,HMD_FORCE_SIBLING ); + } + } +} +void hists__filter_by_thread (struct hists *hists) { -hists__filter_by_type (hists,HIST_FILTER__THREAD , - hists__filter_entry_by_thread); +if (symbol_conf.report_hierarchy) +hists__filter_hierarchy (hists,HIST_FILTER__THREAD , + hists->thread_filter); +else +hists__filter_by_type (hists,HIST_FILTER__THREAD , + hists__filter_entry_by_thread); }void hists__filter_by_dso (struct hists *hists) { -hists__filter_by_type (hists,HIST_FILTER__DSO , - hists__filter_entry_by_dso); +if (symbol_conf.report_hierarchy) +hists__filter_hierarchy (hists,HIST_FILTER__DSO , + hists->dso_filter); +else +hists__filter_by_type (hists,HIST_FILTER__DSO , + hists__filter_entry_by_dso); }void hists__filter_by_symbol (struct hists *hists) { -hists__filter_by_type (hists,HIST_FILTER__SYMBOL , - hists__filter_entry_by_symbol); +if (symbol_conf.report_hierarchy) +hists__filter_hierarchy (hists,HIST_FILTER__SYMBOL , + hists->symbol_filter_str); +else +hists__filter_by_type (hists,HIST_FILTER__SYMBOL , + hists__filter_entry_by_symbol); }void hists__filter_by_socket (struct hists *hists) { -hists__filter_by_type (hists,HIST_FILTER__SOCKET , - hists__filter_entry_by_socket); +if (symbol_conf.report_hierarchy) +hists__filter_hierarchy (hists,HIST_FILTER__SOCKET , + &hists->socket_filter); +else +hists__filter_by_type (hists,HIST_FILTER__SOCKET , + hists__filter_entry_by_socket); }void events_stats__inc (struct events_stats *stats,u32 type)
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists: Support filtering in hierarchy mode
perf hists: Support filtering in hierarchy mode
Commit-ID: 155e9afff77916931f615a394cef187b342530dc Gitweb: http://git.kernel.org/tip/155e9afff77916931f615a394cef187b342530dc Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:38 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:10 -0300
perf hists: Support filtering in hierarchy mode
The hists__filter_hierarchy() function implements filtering in hierarchy mode. Now we have hist_entry__filter() so use it for entries in the hierarchy. It returns 3 kind of values.
A negative value means that it's not filtered by this type. It marks current entry as filtered tentatively so if a lower level entry removes the filter it also removes the all parent so that we can find the entry in the output.
Zero means it's filtered out by this type. A positive value means it's not filtered so it removes the filter and shows in the output. In these cases, it moves to next entry since lower level entry won't match by this type of filter anymore. Thus all children will be filtered or not together.
--- tools/perf/util/hist.c | 101 +++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 93 insertions(+), 8 deletions(-)
tools/perf/util/hist.c +93 -8
@@ -1560,6 +1560,27 @@ static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h enum hist_filter filter) { h->filtered &= ~(1 << filter); + +if (symbol_conf.report_hierarchy) { +struct hist_entry *parent = h->parent_he; + +while (parent) { +he_stat__add_stat (&parent->stat, &h->stat); + + parent->filtered &= ~(1 << filter); + +if (parent->filtered) + goto next; + +/* force fold unfiltered entry for simplicity */ + parent->unfolded = false; + parent->row_offset =0 ; + parent->nr_rows =0 ; +next: + parent = parent->parent_he; + } + } +if (h->filtered)return ;
@@ -1645,28 +1666,92 @@ static void hists__filter_by_type(struct hists *hists, int type, filter_fn_t fil } } +static void hists__filter_hierarchy (struct hists *hists,int type,const void *arg) +{ +struct rb_node *nd; + + hists->stats.nr_non_filtered_samples =0 ; + +hists__reset_filter_stats (hists); +hists__reset_col_len (hists); + + nd =rb_first (&hists->entries); +while (nd) { + struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); +int ret; + + ret =hist_entry__filter (h, type, arg); + +/* +* case 1. non-matching type +* zero out the period, set filter marker and move to child +*/ +if (ret <0 ) { +memset (&h->stat,0 ,sizeof (h->stat)); + h->filtered |= (1 << type); + + nd =__rb_hierarchy_next (&h->rb_node,HMD_FORCE_CHILD ); + } +/* +* case 2. matched type (filter out) +* set filter marker and move to next +*/ +else if (ret ==1 ) { + h->filtered |= (1 << type); + + nd =__rb_hierarchy_next (&h->rb_node,HMD_FORCE_SIBLING ); + } +/* +* case 3. ok (not filtered) +* add period to hists and parents, erase the filter marker +* and move to next sibling +*/ +else { +hists__remove_entry_filter (hists, h, type); + + nd =__rb_hierarchy_next (&h->rb_node,HMD_FORCE_SIBLING ); + } + } +} +void hists__filter_by_thread (struct hists *hists) { -hists__filter_by_type (hists,HIST_FILTER__THREAD , - hists__filter_entry_by_thread); +if (symbol_conf.report_hierarchy) +hists__filter_hierarchy (hists,HIST_FILTER__THREAD , + hists->thread_filter); +else +hists__filter_by_type (hists,HIST_FILTER__THREAD , + hists__filter_entry_by_thread); }void hists__filter_by_dso (struct hists *hists) { -hists__filter_by_type (hists,HIST_FILTER__DSO , - hists__filter_entry_by_dso); +if (symbol_conf.report_hierarchy) +hists__filter_hierarchy (hists,HIST_FILTER__DSO , + hists->dso_filter); +else +hists__filter_by_type (hists,HIST_FILTER__DSO , + hists__filter_entry_by_dso); }void hists__filter_by_symbol (struct hists *hists) { -hists__filter_by_type (hists,HIST_FILTER__SYMBOL , - hists__filter_entry_by_symbol); +if (symbol_conf.report_hierarchy) +hists__filter_hierarchy (hists,HIST_FILTER__SYMBOL , + hists->symbol_filter_str); +else +hists__filter_by_type (hists,HIST_FILTER__SYMBOL , + hists__filter_entry_by_symbol); }void hists__filter_by_socket (struct hists *hists) { -hists__filter_by_type (hists,HIST_FILTER__SOCKET , - hists__filter_entry_by_socket); +if (symbol_conf.report_hierarchy) +hists__filter_hierarchy (hists,HIST_FILTER__SOCKET , + &hists->socket_filter); +else +hists__filter_by_type (hists,HIST_FILTER__SOCKET , + hists__filter_entry_by_socket); }void events_stats__inc (struct events_stats *stats,u32 type)
Namhyung Kim
maintainerPATCH v7 7/18 perf hists: Resort after filtering hierarchy
In reply to Namhyung KimIn hierarchy mode, a filter can affect periods of entries in upper hierarchy. So it needs to resort the hists after filter.
For example, let's look at following example:
Overhead Command / Shared Object / Symbol
------------ --------------------------------
30.00% perf
20.00% perf
10.00% main
5.00% pr_debug
5.00% memcpy
10.00% [kernel.vmlinux]
8.00% memset
2.00% cpu_idleIf we apply simbol filter for 'mem' it should look like this
13.00% perf
8.00% [kernel.vmlinux]
8.00% memset
5.00% perf
5.00% memcpy--- tools/perf/util/hist.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+)
tools/perf/util/hist.c +54 -0
@@ -1667,9 +1667,47 @@ static void hists__filter_by_type(struct hists *hists, int type, filter_fn_t fil } } +static void resort_filtered_entry (struct rb_root *root,struct hist_entry *he) +{ +struct rb_node **p = &root->rb_node; +struct rb_node *parent =NULL ; +struct hist_entry *iter; +struct rb_root new_root =RB_ROOT ; +struct rb_node *nd; + +while (*p !=NULL ) { + parent = *p; + iter = rb_entry(parent, struct hist_entry, rb_node); + +if (hist_entry__sort (he, iter) >0 ) + p = &(*p)->rb_left; +else + p = &(*p)->rb_right; + } + +rb_link_node (&he->rb_node, parent, p); +rb_insert_color (&he->rb_node, root); + +if (he->leaf || he->filtered) +return ; + + nd =rb_first (&he->hroot_out); +while (nd) { + struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); + + nd =rb_next (nd); +rb_erase (&h->rb_node, &he->hroot_out); + +resort_filtered_entry (&new_root, h); + } + + he->hroot_out = new_root; +} +static void hists__filter_hierarchy (struct hists *hists,int type,const void *arg) {struct rb_node *nd; +struct rb_root new_root =RB_ROOT ; hists->stats.nr_non_filtered_samples =0 ;
@@ -1713,6 +1751,22 @@ static void hists__filter_hierarchy(struct hists *hists, int type, const void *a nd =__rb_hierarchy_next (&h->rb_node,HMD_FORCE_SIBLING ); } } + +/* +* resort output after applying a new filter since filter in a lower +* hierarchy can change periods in a upper hierarchy. +*/ + nd =rb_first (&hists->entries); +while (nd) { + struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); + + nd =rb_next (nd); +rb_erase (&h->rb_node, &hists->entries); + +resort_filtered_entry (&new_root, h); + } + + hists->entries = new_root; }void hists__filter_by_thread (struct hists *hists)
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists: Resort after filtering hierarchy
perf hists: Resort after filtering hierarchy
Commit-ID: 70642850fa581df219d7bc03cd7aca6e1956968c Gitweb: http://git.kernel.org/tip/70642850fa581df219d7bc03cd7aca6e1956968c Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:39 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:11 -0300
perf hists: Resort after filtering hierarchy
In hierarchy mode, a filter can affect periods of entries in upper hierarchy. So it needs to resort the hists after filter.
For example, let's look at following example:
Overhead Command / Shared Object / Symbol
------------ --------------------------------
30.00% perf
20.00% perf
10.00% main
5.00% pr_debug
5.00% memcpy
10.00% [kernel.vmlinux]
8.00% memset
2.00% cpu_idleIf we apply simbol filter for 'mem' it should look like this
13.00% perf
8.00% [kernel.vmlinux]
8.00% memset
5.00% perf
5.00% memcpy--- tools/perf/util/hist.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+)
tools/perf/util/hist.c +54 -0
@@ -1666,9 +1666,47 @@ static void hists__filter_by_type(struct hists *hists, int type, filter_fn_t fil } } +static void resort_filtered_entry (struct rb_root *root,struct hist_entry *he) +{ +struct rb_node **p = &root->rb_node; +struct rb_node *parent =NULL ; +struct hist_entry *iter; +struct rb_root new_root =RB_ROOT ; +struct rb_node *nd; + +while (*p !=NULL ) { + parent = *p; + iter = rb_entry(parent, struct hist_entry, rb_node); + +if (hist_entry__sort (he, iter) >0 ) + p = &(*p)->rb_left; +else + p = &(*p)->rb_right; + } + +rb_link_node (&he->rb_node, parent, p); +rb_insert_color (&he->rb_node, root); + +if (he->leaf || he->filtered) +return ; + + nd =rb_first (&he->hroot_out); +while (nd) { + struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); + + nd =rb_next (nd); +rb_erase (&h->rb_node, &he->hroot_out); + +resort_filtered_entry (&new_root, h); + } + + he->hroot_out = new_root; +} +static void hists__filter_hierarchy (struct hists *hists,int type,const void *arg) {struct rb_node *nd; +struct rb_root new_root =RB_ROOT ; hists->stats.nr_non_filtered_samples =0 ;
@@ -1712,6 +1750,22 @@ static void hists__filter_hierarchy(struct hists *hists, int type, const void *a nd =__rb_hierarchy_next (&h->rb_node,HMD_FORCE_SIBLING ); } } + +/* +* resort output after applying a new filter since filter in a lower +* hierarchy can change periods in a upper hierarchy. +*/ + nd =rb_first (&hists->entries); +while (nd) { + struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); + + nd =rb_next (nd); +rb_erase (&h->rb_node, &hists->entries); + +resort_filtered_entry (&new_root, h); + } + + hists->entries = new_root; }void hists__filter_by_thread (struct hists *hists)
Namhyung Kim
maintainerPATCH v7 8/18 perf hists: Count number of sort keys
In reply to Namhyung KimIt'll be used for hierarchy output mode to indent entries properly.
--- tools/perf/ui/hist.c | 3 +++ tools/perf/util/hist.h | 1 + 2 files changed, 4 insertions(+)
tools/perf/ui/hist.c +3 -0
@@ -514,6 +514,9 @@ void perf_hpp_list__column_register(struct perf_hpp_list *list,void perf_hpp_list__register_sort_field (struct perf_hpp_list *list,struct perf_hpp_fmt *format) { +if (perf_hpp__is_sort_entry (format) ||perf_hpp__is_dynamic_entry (format)) + list->nr_sort_keys++; +list_add_tail (&format->sort_list, &list->sorts); }
tools/perf/util/hist.h +1 -0
@@ -237,6 +237,7 @@ struct perf_hpp_fmt {struct perf_hpp_list {struct list_head fields;struct list_head sorts; +int nr_sort_keys; };extern struct perf_hpp_list perf_hpp_list;
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists: Count number of sort keys
perf hists: Count number of sort keys
Commit-ID: 1f2d72cf3258eacd667cd1920e64c9b64b9984d5 Gitweb: http://git.kernel.org/tip/1f2d72cf3258eacd667cd1920e64c9b64b9984d5 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:40 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:11 -0300
perf hists: Count number of sort keys
It'll be used for hierarchy output mode to indent entries properly.
--- tools/perf/ui/hist.c | 3 +++ tools/perf/util/hist.h | 1 + 2 files changed, 4 insertions(+)
tools/perf/ui/hist.c +3 -0
@@ -514,6 +514,9 @@ void perf_hpp_list__column_register(struct perf_hpp_list *list,void perf_hpp_list__register_sort_field (struct perf_hpp_list *list,struct perf_hpp_fmt *format) { +if (perf_hpp__is_sort_entry (format) ||perf_hpp__is_dynamic_entry (format)) + list->nr_sort_keys++; +list_add_tail (&format->sort_list, &list->sorts); }
tools/perf/util/hist.h +1 -0
@@ -237,6 +237,7 @@ struct perf_hpp_fmt {struct perf_hpp_list {struct list_head fields;struct list_head sorts; +int nr_sort_keys; };extern struct perf_hpp_list perf_hpp_list;
Namhyung Kim
maintainerPATCH v7 9/18 perf ui/stdio: Implement hierarchy output mode
In reply to Namhyung KimThe hierarchy output mode is to group entries for each level so that user can see higher level picture more easily. It also helps to find out which component is most costly. The output will look like below:
15.11% swapper
14.97% [kernel.vmlinux]
0.09% [libahci]
0.05% [iwlwifi]
10.29% irq/33-iwlwifi
6.45% [kernel.vmlinux]
1.41% [mac80211]
1.15% [iwldvm]
1.14% [iwlwifi]
0.14% [cfg80211]
4.81% firefox
3.92% libxul.so
0.34% [kernel.vmlinux]--- tools/perf/ui/stdio/hist.c | 79 +++++++++++++++++++++++++++++++++++++++++++++- tools/perf/util/hist.h | 2 ++ 2 files changed, 80 insertions(+), 1 deletion(-)
tools/perf/ui/stdio/hist.c +78 -1
@@ -410,6 +410,76 @@ static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)return hpp->buf - start; } +static int hist_entry__hierarchy_fprintf (struct hist_entry *he, +struct perf_hpp *hpp, +int nr_sort_key,struct hists *hists, +FILE *fp) +{ +const char *sep = symbol_conf.field_sep; +struct perf_hpp_fmt *fmt; +char *buf = hpp->buf; +int ret, printed =0 ; +bool first = true; + +if (symbol_conf.exclude_other && !he->parent) +return 0 ; + + ret =scnprintf (hpp->buf, hpp->size,"%*s" , he->depth *HIERARCHY_INDENT ,"" ); +advance_hpp (hpp, ret); + +hists__for_each_format (he->hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) ||perf_hpp__is_dynamic_entry (fmt)) +break ; + +/* +* If there's no field_sep, we still need +* to display initial ' '. +*/ +if (!sep || !first) { + ret =scnprintf (hpp->buf, hpp->size,"%s" , sep ?:" " ); +advance_hpp (hpp, ret); + }else + first = false; + +if (perf_hpp__use_color () && fmt->color) + ret = fmt->color (fmt, hpp, he); +else + ret = fmt->entry (fmt, hpp, he); + + ret =hist_entry__snprintf_alignment (he, hpp, fmt, ret); +advance_hpp (hpp, ret); + } + +if (sep) + ret =scnprintf (hpp->buf, hpp->size,"%s" , sep); +else + ret =scnprintf (hpp->buf, hpp->size,"%*s" , + (nr_sort_key -1 ) *HIERARCHY_INDENT +2 ,"" ); +advance_hpp (hpp, ret); + +/* +* No need to call hist_entry__snprintf_alignment() since this +* fmt is always the last column in the hierarchy mode. +*/ + fmt = he->fmt; +if (perf_hpp__use_color () && fmt->color) + fmt->color (fmt, hpp, he); +else + fmt->entry (fmt, hpp, he); + + printed +=fprintf (fp,"%s\n" , buf); + +if (symbol_conf.use_callchain && he->leaf) { +u64 total =hists__total_period (hists); + + printed +=hist_entry_callchain__fprintf (he, total,0 , fp); + goto out; + } + +out: +return printed; +} +static int hist_entry__fprintf (struct hist_entry *he,size_t size,struct hists *hists,char *bf,size_t bfsz,FILE *fp)
@@ -424,6 +494,13 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,if (size ==0 || size > bfsz) size = hpp.size = bfsz; +if (symbol_conf.report_hierarchy) { +int nr_sort = hists->hpp_list->nr_sort_keys; + +return hist_entry__hierarchy_fprintf (he, &hpp, nr_sort, + hists, fp); + } +hist_entry__snprintf (he, &hpp); ret =fprintf (fp,"%s\n" , bf);
@@ -522,7 +599,7 @@ print_entries: goto out; } -for (nd =rb_first (&hists->entries); nd; nd =rb_next (nd)) { +for (nd =rb_first (&hists->entries); nd; nd =__rb_hierarchy_next (nd,HMD_FORCE_CHILD )) { struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);float percent;
tools/perf/util/hist.h +2 -0
@@ -437,4 +437,6 @@ static inline struct rb_node *rb_hierarchy_next(struct rb_node *node) return __rb_hierarchy_next(node, HMD_NORMAL); } +#define HIERARCHY_INDENT 3 +#endif /* __PERF_HIST_H */
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf ui/stdio: Implement hierarchy output mode
perf ui/stdio: Implement hierarchy output mode
Commit-ID: ef86d68a088c324e4bd85f82387d1f9a571affd0 Gitweb: http://git.kernel.org/tip/ef86d68a088c324e4bd85f82387d1f9a571affd0 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:41 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:12 -0300
perf ui/stdio: Implement hierarchy output mode
The hierarchy output mode is to group entries for each level so that user can see higher level picture more easily. It also helps to find out which component is most costly. The output will look like below:
15.11% swapper
14.97% [kernel.vmlinux]
0.09% [libahci]
0.05% [iwlwifi]
10.29% irq/33-iwlwifi
6.45% [kernel.vmlinux]
1.41% [mac80211]
1.15% [iwldvm]
1.14% [iwlwifi]
0.14% [cfg80211]
4.81% firefox
3.92% libxul.so
0.34% [kernel.vmlinux]--- tools/perf/ui/stdio/hist.c | 79 +++++++++++++++++++++++++++++++++++++++++++++- tools/perf/util/hist.h | 2 ++ 2 files changed, 80 insertions(+), 1 deletion(-)
tools/perf/ui/stdio/hist.c +78 -1
@@ -410,6 +410,76 @@ static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)return hpp->buf - start; } +static int hist_entry__hierarchy_fprintf (struct hist_entry *he, +struct perf_hpp *hpp, +int nr_sort_key,struct hists *hists, +FILE *fp) +{ +const char *sep = symbol_conf.field_sep; +struct perf_hpp_fmt *fmt; +char *buf = hpp->buf; +int ret, printed =0 ; +bool first = true; + +if (symbol_conf.exclude_other && !he->parent) +return 0 ; + + ret =scnprintf (hpp->buf, hpp->size,"%*s" , he->depth *HIERARCHY_INDENT ,"" ); +advance_hpp (hpp, ret); + +hists__for_each_format (he->hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) ||perf_hpp__is_dynamic_entry (fmt)) +break ; + +/* +* If there's no field_sep, we still need +* to display initial ' '. +*/ +if (!sep || !first) { + ret =scnprintf (hpp->buf, hpp->size,"%s" , sep ?:" " ); +advance_hpp (hpp, ret); + }else + first = false; + +if (perf_hpp__use_color () && fmt->color) + ret = fmt->color (fmt, hpp, he); +else + ret = fmt->entry (fmt, hpp, he); + + ret =hist_entry__snprintf_alignment (he, hpp, fmt, ret); +advance_hpp (hpp, ret); + } + +if (sep) + ret =scnprintf (hpp->buf, hpp->size,"%s" , sep); +else + ret =scnprintf (hpp->buf, hpp->size,"%*s" , + (nr_sort_key -1 ) *HIERARCHY_INDENT +2 ,"" ); +advance_hpp (hpp, ret); + +/* +* No need to call hist_entry__snprintf_alignment() since this +* fmt is always the last column in the hierarchy mode. +*/ + fmt = he->fmt; +if (perf_hpp__use_color () && fmt->color) + fmt->color (fmt, hpp, he); +else + fmt->entry (fmt, hpp, he); + + printed +=fprintf (fp,"%s\n" , buf); + +if (symbol_conf.use_callchain && he->leaf) { +u64 total =hists__total_period (hists); + + printed +=hist_entry_callchain__fprintf (he, total,0 , fp); + goto out; + } + +out: +return printed; +} +static int hist_entry__fprintf (struct hist_entry *he,size_t size,struct hists *hists,char *bf,size_t bfsz,FILE *fp)
@@ -424,6 +494,13 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,if (size ==0 || size > bfsz) size = hpp.size = bfsz; +if (symbol_conf.report_hierarchy) { +int nr_sort = hists->hpp_list->nr_sort_keys; + +return hist_entry__hierarchy_fprintf (he, &hpp, nr_sort, + hists, fp); + } +hist_entry__snprintf (he, &hpp); ret =fprintf (fp,"%s\n" , bf);
@@ -522,7 +599,7 @@ print_entries: goto out; } -for (nd =rb_first (&hists->entries); nd; nd =rb_next (nd)) { +for (nd =rb_first (&hists->entries); nd; nd =__rb_hierarchy_next (nd,HMD_FORCE_CHILD )) { struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);float percent;
tools/perf/util/hist.h +2 -0
@@ -437,4 +437,6 @@ static inline struct rb_node *rb_hierarchy_next(struct rb_node *node) return __rb_hierarchy_next(node, HMD_NORMAL); } +#define HIERARCHY_INDENT 3 +#endif /* __PERF_HIST_H */
Namhyung Kim
maintainerPATCH v7 10/18 perf ui/stdio: Align column header for hierarchy output
In reply to Namhyung KimThe hierarchy output mode is to group entries so the existing columns won't fit to the new output. Treat all sort keys as a single column and separate headers by "/".
# Overhead Command / Shared Object
# ........... ................................
#
15.11% swapper
14.97% [kernel.vmlinux]
0.09% [libahci]
0.05% [iwlwifi]
...--- tools/perf/ui/stdio/hist.c | 105 +++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/ctype.c | 9 ++++ tools/perf/util/util.h | 2 + 3 files changed, 116 insertions(+)
tools/perf/ui/stdio/hist.c +105 -0
@@ -511,6 +511,106 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,return ret; } +static int print_hierarchy_indent (const char *sep,int nr_sort, +const char *line,FILE *fp) +{ +if (sep !=NULL || nr_sort <1 ) +return 0 ; + +return fprintf (fp,"%-.*s" , (nr_sort -1 ) *HIERARCHY_INDENT , line); +} + +static int print_hierarchy_header (struct hists *hists,struct perf_hpp *hpp, +const char *sep,FILE *fp) +{ +bool first = true; +int nr_sort; +unsigned width =0 ; +unsigned header_width =0 ; +struct perf_hpp_fmt *fmt; + + nr_sort = hists->hpp_list->nr_sort_keys; + +/* preserve max indent depth for column headers */ +print_hierarchy_indent (sep, nr_sort, spaces, fp); + +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) ||perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (!first) +fprintf (fp,"%s" , sep ?:" " ); +else + first = false; + + fmt->header (fmt, hpp,hists_to_evsel (hists)); +fprintf (fp,"%s" , hpp->buf); + } + +/* combine sort headers with ' / ' */ + first = true; +hists__for_each_format (hists, fmt) { +if (!perf_hpp__is_sort_entry (fmt) && !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + +if (!first) + header_width +=fprintf (fp," / " ); +else { + header_width +=fprintf (fp,"%s" , sep ?:" " ); + first = false; + } + + fmt->header (fmt, hpp,hists_to_evsel (hists)); +rtrim (hpp->buf); + + header_width +=fprintf (fp,"%s" , hpp->buf); + } + +/* preserve max indent depth for combined sort headers */ +print_hierarchy_indent (sep, nr_sort, spaces, fp); + +fprintf (fp,"\n# " ); + +/* preserve max indent depth for initial dots */ +print_hierarchy_indent (sep, nr_sort, dots, fp); + + first = true; +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) ||perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (!first) +fprintf (fp,"%s" , sep ?:" " ); +else + first = false; + + width = fmt->width (fmt, hpp,hists_to_evsel (hists)); +fprintf (fp,"%.*s" , width, dots); + } + +hists__for_each_format (hists, fmt) { +if (!perf_hpp__is_sort_entry (fmt) && !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + + width = fmt->width (fmt, hpp,hists_to_evsel (hists)); +if (width > header_width) + header_width = width; + } + +fprintf (fp,"%s%-.*s" , sep ?:" " , header_width, dots); + +/* preserve max indent depth for dots under sort headers */ +print_hierarchy_indent (sep, nr_sort, dots, fp); + +fprintf (fp,"\n#\n" ); + +return 2 ; +} +size_t hists__fprintf (struct hists *hists,bool show_header,int max_rows,int max_cols,float min_pcnt,FILE *fp) {
@@ -542,6 +642,11 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,fprintf (fp,"# " ); +if (symbol_conf.report_hierarchy) { + nr_rows +=print_hierarchy_header (hists, &dummy_hpp, sep, fp); + goto print_entries; + } +hists__for_each_format (hists, fmt) {if (perf_hpp__should_skip (fmt, hists))continue ;
tools/perf/util/ctype.c +9 -0
@@ -32,8 +32,17 @@ unsigned char sane_ctype[256] = {const char *graph_line ="_____________________________________________________________________" +"_____________________________________________________________________" "_____________________________________________________________________" ;const char *graph_dotted_line ="---------------------------------------------------------------------" "---------------------------------------------------------------------" "---------------------------------------------------------------------" ; +const char *spaces = +" " +" " +" " ; +const char *dots = +"....................................................................." +"....................................................................." +"....................................................................." ;
tools/perf/util/util.h +2 -0
@@ -82,6 +82,8 @@extern const char *graph_line;extern const char *graph_dotted_line; +extern const char *spaces; +extern const char *dots;extern char buildid_dir[];/* On most systems <limits.h> would have given us this, but
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf ui/stdio: Align column header for hierarchy output
perf ui/stdio: Align column header for hierarchy output
Commit-ID: 8e2fc44f46ba4d3d1ee8b6ba0839a282a9f3fdd7 Gitweb: http://git.kernel.org/tip/8e2fc44f46ba4d3d1ee8b6ba0839a282a9f3fdd7 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:42 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:12 -0300
perf ui/stdio: Align column header for hierarchy output
The hierarchy output mode is to group entries so the existing columns won't fit to the new output. Treat all sort keys as a single column and separate headers by "/".
# Overhead Command / Shared Object
# ........... ................................
#
15.11% swapper
14.97% [kernel.vmlinux]
0.09% [libahci]
0.05% [iwlwifi]
...--- tools/perf/ui/stdio/hist.c | 105 +++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/ctype.c | 9 ++++ tools/perf/util/util.h | 2 + 3 files changed, 116 insertions(+)
tools/perf/ui/stdio/hist.c +105 -0
@@ -511,6 +511,106 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,return ret; } +static int print_hierarchy_indent (const char *sep,int nr_sort, +const char *line,FILE *fp) +{ +if (sep !=NULL || nr_sort <1 ) +return 0 ; + +return fprintf (fp,"%-.*s" , (nr_sort -1 ) *HIERARCHY_INDENT , line); +} + +static int print_hierarchy_header (struct hists *hists,struct perf_hpp *hpp, +const char *sep,FILE *fp) +{ +bool first = true; +int nr_sort; +unsigned width =0 ; +unsigned header_width =0 ; +struct perf_hpp_fmt *fmt; + + nr_sort = hists->hpp_list->nr_sort_keys; + +/* preserve max indent depth for column headers */ +print_hierarchy_indent (sep, nr_sort, spaces, fp); + +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) ||perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (!first) +fprintf (fp,"%s" , sep ?:" " ); +else + first = false; + + fmt->header (fmt, hpp,hists_to_evsel (hists)); +fprintf (fp,"%s" , hpp->buf); + } + +/* combine sort headers with ' / ' */ + first = true; +hists__for_each_format (hists, fmt) { +if (!perf_hpp__is_sort_entry (fmt) && !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + +if (!first) + header_width +=fprintf (fp," / " ); +else { + header_width +=fprintf (fp,"%s" , sep ?:" " ); + first = false; + } + + fmt->header (fmt, hpp,hists_to_evsel (hists)); +rtrim (hpp->buf); + + header_width +=fprintf (fp,"%s" , hpp->buf); + } + +/* preserve max indent depth for combined sort headers */ +print_hierarchy_indent (sep, nr_sort, spaces, fp); + +fprintf (fp,"\n# " ); + +/* preserve max indent depth for initial dots */ +print_hierarchy_indent (sep, nr_sort, dots, fp); + + first = true; +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) ||perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (!first) +fprintf (fp,"%s" , sep ?:" " ); +else + first = false; + + width = fmt->width (fmt, hpp,hists_to_evsel (hists)); +fprintf (fp,"%.*s" , width, dots); + } + +hists__for_each_format (hists, fmt) { +if (!perf_hpp__is_sort_entry (fmt) && !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + + width = fmt->width (fmt, hpp,hists_to_evsel (hists)); +if (width > header_width) + header_width = width; + } + +fprintf (fp,"%s%-.*s" , sep ?:" " , header_width, dots); + +/* preserve max indent depth for dots under sort headers */ +print_hierarchy_indent (sep, nr_sort, dots, fp); + +fprintf (fp,"\n#\n" ); + +return 2 ; +} +size_t hists__fprintf (struct hists *hists,bool show_header,int max_rows,int max_cols,float min_pcnt,FILE *fp) {
@@ -542,6 +642,11 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,fprintf (fp,"# " ); +if (symbol_conf.report_hierarchy) { + nr_rows +=print_hierarchy_header (hists, &dummy_hpp, sep, fp); + goto print_entries; + } +hists__for_each_format (hists, fmt) {if (perf_hpp__should_skip (fmt, hists))continue ;
tools/perf/util/ctype.c +9 -0
@@ -32,8 +32,17 @@ unsigned char sane_ctype[256] = {const char *graph_line ="_____________________________________________________________________" +"_____________________________________________________________________" "_____________________________________________________________________" ;const char *graph_dotted_line ="---------------------------------------------------------------------" "---------------------------------------------------------------------" "---------------------------------------------------------------------" ; +const char *spaces = +" " +" " +" " ; +const char *dots = +"....................................................................." +"....................................................................." +"....................................................................." ;
tools/perf/util/util.h +2 -0
@@ -82,6 +82,8 @@extern const char *graph_line;extern const char *graph_dotted_line; +extern const char *spaces; +extern const char *dots;extern char buildid_dir[];/* On most systems <limits.h> would have given us this, but
Namhyung Kim
maintainerPATCH v7 11/18 perf hists browser: Count number of hierarchy entries
In reply to Namhyung KimAdd nr_hierarchy_entries field to keep current number of (unfolded) hist entries. And the hist_entry->nr_rows carries number of direct children. But in the hierarchy mode, entry can have grand children and callchains. So update the number properly using hierarchy_count_rows() when toggling the folded state (by pressing ENTER key).
--- tools/perf/ui/browsers/hists.c | 85 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 74 insertions(+), 11 deletions(-)
tools/perf/ui/browsers/hists.c +74 -11
@@ -32,6 +32,7 @@ struct hist_browser {bool show_headers;float min_pcnt;u64 nr_non_filtered_entries; +u64 nr_hierarchy_entries;u64 nr_callchain_rows; };
@@ -58,11 +59,11 @@ static int hist_browser__get_folding(struct hist_browser *browser)for (nd =rb_first (&hists->entries); (nd =hists__filter_entries (nd, browser->min_pcnt)) !=NULL ; - nd =rb_next (nd)) { + nd =rb_hierarchy_next (nd)) {struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node); -if (he->unfolded) +if (he->leaf && he->unfolded) unfolded_rows += he->nr_rows; }return unfolded_rows;
@@ -72,7 +73,9 @@ static u32 hist_browser__nr_entries(struct hist_browser *hb) {u32 nr_entries; -if (hist_browser__has_filter (hb)) +if (symbol_conf.report_hierarchy) + nr_entries = hb->nr_hierarchy_entries; +else if (hist_browser__has_filter (hb)) nr_entries = hb->nr_non_filtered_entries;else nr_entries = hb->hists->nr_entries;
@@ -247,6 +250,35 @@ static int callchain__count_rows(struct rb_root *chain)return n; } +static int hierarchy_count_rows (struct hist_browser *hb,struct hist_entry *he, +bool include_children) +{ +int count =0 ; +struct rb_node *node; +struct hist_entry *child; + +if (he->leaf) +return callchain__count_rows (&he->sorted_chain); + + node =rb_first (&he->hroot_out); +while (node) { +float percent; + + child = rb_entry(node, struct hist_entry, rb_node); + percent =hist_entry__get_percent_limit (child); + +if (!child->filtered && percent >= hb->min_pcnt) { + count++; + +if (include_children && child->unfolded) + count +=hierarchy_count_rows (hb, child, true); + } + + node =rb_next (node); + } +return count; +} +static bool hist_entry__toggle_fold (struct hist_entry *he) {if (!he)
@@ -326,11 +358,17 @@ static void callchain__init_have_children(struct rb_root *root)static void hist_entry__init_have_children (struct hist_entry *he) { -if (!he->init_have_children) { +if (he->init_have_children) +return ; + +if (he->leaf) { he->has_children = !RB_EMPTY_ROOT (&he->sorted_chain);callchain__init_have_children (&he->sorted_chain); - he->init_have_children = true; + }else { + he->has_children = !RB_EMPTY_ROOT (&he->hroot_out); } + + he->init_have_children = true; }static bool hist_browser__toggle_fold (struct hist_browser *browser)
@@ -349,17 +387,41 @@ static bool hist_browser__toggle_fold(struct hist_browser *browser) has_children =callchain_list__toggle_fold (cl);if (has_children) { +int child_rows =0 ; +hist_entry__init_have_children (he); browser->b.nr_entries -= he->nr_rows; - browser->nr_callchain_rows -= he->nr_rows; -if (he->unfolded) - he->nr_rows =callchain__count_rows (&he->sorted_chain); +if (he->leaf) + browser->nr_callchain_rows -= he->nr_rows;else + browser->nr_hierarchy_entries -= he->nr_rows; + +if (symbol_conf.report_hierarchy) + child_rows =hierarchy_count_rows (browser, he, true); + +if (he->unfolded) { +if (he->leaf) + he->nr_rows =callchain__count_rows (&he->sorted_chain); +else + he->nr_rows =hierarchy_count_rows (browser, he, false); + +/* account grand children */ +if (symbol_conf.report_hierarchy) + browser->b.nr_entries += child_rows - he->nr_rows; + }else { +if (symbol_conf.report_hierarchy) + browser->b.nr_entries -= child_rows - he->nr_rows; + he->nr_rows =0 ; + } browser->b.nr_entries += he->nr_rows; - browser->nr_callchain_rows += he->nr_rows; + +if (he->leaf) + browser->nr_callchain_rows += he->nr_rows; +else + browser->nr_hierarchy_entries += he->nr_rows;return true; }
@@ -2025,17 +2087,18 @@ static void hist_browser__update_nr_entries(struct hist_browser *hb)u64 nr_entries =0 ;struct rb_node *nd =rb_first (&hb->hists->entries); -if (hb->min_pcnt ==0 ) { +if (hb->min_pcnt ==0 && !symbol_conf.report_hierarchy) { hb->nr_non_filtered_entries = hb->hists->nr_non_filtered_entries;return ; }while ((nd =hists__filter_entries (nd, hb->min_pcnt)) !=NULL ) { nr_entries++; - nd =rb_next (nd); + nd =rb_hierarchy_next (nd); } hb->nr_non_filtered_entries = nr_entries; + hb->nr_hierarchy_entries = nr_entries; } static void hist_browser__update_percent_limit(struct hist_browser *hb,
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists browser: Count number of hierarchy entries
perf hists browser: Count number of hierarchy entries
Commit-ID: f5b763feebe9770c3e6b01f1e19860e95f24b623 Gitweb: http://git.kernel.org/tip/f5b763feebe9770c3e6b01f1e19860e95f24b623 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:43 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:12 -0300
perf hists browser: Count number of hierarchy entries
Add nr_hierarchy_entries field to keep current number of (unfolded) hist entries. And the hist_entry->nr_rows carries number of direct children. But in the hierarchy mode, entry can have grand children and callchains. So update the number properly using hierarchy_count_rows() when toggling the folded state (by pressing ENTER key).
--- tools/perf/ui/browsers/hists.c | 85 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 74 insertions(+), 11 deletions(-)
tools/perf/ui/browsers/hists.c +74 -11
@@ -32,6 +32,7 @@ struct hist_browser {bool show_headers;float min_pcnt;u64 nr_non_filtered_entries; +u64 nr_hierarchy_entries;u64 nr_callchain_rows; };
@@ -58,11 +59,11 @@ static int hist_browser__get_folding(struct hist_browser *browser)for (nd =rb_first (&hists->entries); (nd =hists__filter_entries (nd, browser->min_pcnt)) !=NULL ; - nd =rb_next (nd)) { + nd =rb_hierarchy_next (nd)) {struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node); -if (he->unfolded) +if (he->leaf && he->unfolded) unfolded_rows += he->nr_rows; }return unfolded_rows;
@@ -72,7 +73,9 @@ static u32 hist_browser__nr_entries(struct hist_browser *hb) {u32 nr_entries; -if (hist_browser__has_filter (hb)) +if (symbol_conf.report_hierarchy) + nr_entries = hb->nr_hierarchy_entries; +else if (hist_browser__has_filter (hb)) nr_entries = hb->nr_non_filtered_entries;else nr_entries = hb->hists->nr_entries;
@@ -247,6 +250,35 @@ static int callchain__count_rows(struct rb_root *chain)return n; } +static int hierarchy_count_rows (struct hist_browser *hb,struct hist_entry *he, +bool include_children) +{ +int count =0 ; +struct rb_node *node; +struct hist_entry *child; + +if (he->leaf) +return callchain__count_rows (&he->sorted_chain); + + node =rb_first (&he->hroot_out); +while (node) { +float percent; + + child = rb_entry(node, struct hist_entry, rb_node); + percent =hist_entry__get_percent_limit (child); + +if (!child->filtered && percent >= hb->min_pcnt) { + count++; + +if (include_children && child->unfolded) + count +=hierarchy_count_rows (hb, child, true); + } + + node =rb_next (node); + } +return count; +} +static bool hist_entry__toggle_fold (struct hist_entry *he) {if (!he)
@@ -326,11 +358,17 @@ static void callchain__init_have_children(struct rb_root *root)static void hist_entry__init_have_children (struct hist_entry *he) { -if (!he->init_have_children) { +if (he->init_have_children) +return ; + +if (he->leaf) { he->has_children = !RB_EMPTY_ROOT (&he->sorted_chain);callchain__init_have_children (&he->sorted_chain); - he->init_have_children = true; + }else { + he->has_children = !RB_EMPTY_ROOT (&he->hroot_out); } + + he->init_have_children = true; }static bool hist_browser__toggle_fold (struct hist_browser *browser)
@@ -349,17 +387,41 @@ static bool hist_browser__toggle_fold(struct hist_browser *browser) has_children =callchain_list__toggle_fold (cl);if (has_children) { +int child_rows =0 ; +hist_entry__init_have_children (he); browser->b.nr_entries -= he->nr_rows; - browser->nr_callchain_rows -= he->nr_rows; -if (he->unfolded) - he->nr_rows =callchain__count_rows (&he->sorted_chain); +if (he->leaf) + browser->nr_callchain_rows -= he->nr_rows;else + browser->nr_hierarchy_entries -= he->nr_rows; + +if (symbol_conf.report_hierarchy) + child_rows =hierarchy_count_rows (browser, he, true); + +if (he->unfolded) { +if (he->leaf) + he->nr_rows =callchain__count_rows (&he->sorted_chain); +else + he->nr_rows =hierarchy_count_rows (browser, he, false); + +/* account grand children */ +if (symbol_conf.report_hierarchy) + browser->b.nr_entries += child_rows - he->nr_rows; + }else { +if (symbol_conf.report_hierarchy) + browser->b.nr_entries -= child_rows - he->nr_rows; + he->nr_rows =0 ; + } browser->b.nr_entries += he->nr_rows; - browser->nr_callchain_rows += he->nr_rows; + +if (he->leaf) + browser->nr_callchain_rows += he->nr_rows; +else + browser->nr_hierarchy_entries += he->nr_rows;return true; }
@@ -2025,17 +2087,18 @@ static void hist_browser__update_nr_entries(struct hist_browser *hb)u64 nr_entries =0 ;struct rb_node *nd =rb_first (&hb->hists->entries); -if (hb->min_pcnt ==0 ) { +if (hb->min_pcnt ==0 && !symbol_conf.report_hierarchy) { hb->nr_non_filtered_entries = hb->hists->nr_non_filtered_entries;return ; }while ((nd =hists__filter_entries (nd, hb->min_pcnt)) !=NULL ) { nr_entries++; - nd =rb_next (nd); + nd =rb_hierarchy_next (nd); } hb->nr_non_filtered_entries = nr_entries; + hb->nr_hierarchy_entries = nr_entries; } static void hist_browser__update_percent_limit(struct hist_browser *hb,
Namhyung Kim
maintainerPATCH v7 12/18 perf hists browser: Support collapsing/expanding whole entries in hierarchy
In reply to Namhyung KimThe 'C' and 'E' keys are to collapse/expand all hist entries. Update nr_hierarchy_entries properly in this case.
--- tools/perf/ui/browsers/hists.c | 58 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 48 insertions(+), 10 deletions(-)
tools/perf/ui/browsers/hists.c +48 -10
@@ -484,13 +484,38 @@ static int callchain__set_folding(struct rb_root *chain, bool unfold)return n; } -static void hist_entry__set_folding (struct hist_entry *he,bool unfold) +static int hierarchy_set_folding (struct hist_browser *hb,struct hist_entry *he, +bool unfold__maybe_unused ) +{ +float percent; +struct rb_node *nd; +struct hist_entry *child; +int n =0 ; + +for (nd =rb_first (&he->hroot_out); nd; nd =rb_next (nd)) { + child = rb_entry(nd, struct hist_entry, rb_node); + percent =hist_entry__get_percent_limit (child); +if (!child->filtered && percent >= hb->min_pcnt) + n++; + } + +return n; +} + +static void hist_entry__set_folding (struct hist_entry *he, +struct hist_browser *hb,bool unfold) {hist_entry__init_have_children (he); he->unfolded = unfold ? he->has_children : false;if (he->has_children) { -int n =callchain__set_folding (&he->sorted_chain, unfold); +int n; + +if (he->leaf) + n =callchain__set_folding (&he->sorted_chain, unfold); +else + n =hierarchy_set_folding (hb, he, unfold); + he->nr_rows = unfold ? n :0 ; }else he->nr_rows =0 ;
@@ -500,19 +525,32 @@ static void __hist_browser__set_folding(struct hist_browser *browser, bool unfold) {struct rb_node *nd; -struct hists *hists = browser->hists; +struct hist_entry *he; +double percent; -for (nd =rb_first (&hists->entries); - (nd =hists__filter_entries (nd, browser->min_pcnt)) !=NULL ; - nd =rb_next (nd)) { - struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node); -hist_entry__set_folding (he, unfold); - browser->nr_callchain_rows += he->nr_rows; + nd =rb_first (&browser->hists->entries); +while (nd) { + he = rb_entry(nd, struct hist_entry, rb_node); + +/* set folding state even if it's currently folded */ + nd =__rb_hierarchy_next (nd,HMD_FORCE_CHILD ); + +hist_entry__set_folding (he, browser, unfold); + + percent =hist_entry__get_percent_limit (he); +if (he->filtered || percent < browser->min_pcnt) +continue ; + +if (!he->depth || unfold) + browser->nr_hierarchy_entries++; +if (he->leaf) + browser->nr_callchain_rows += he->nr_rows; } }static void hist_browser__set_folding (struct hist_browser *browser,bool unfold) { + browser->nr_hierarchy_entries =0 ; browser->nr_callchain_rows =0 ;__hist_browser__set_folding (browser, unfold);
@@ -2131,7 +2169,7 @@ static void hist_browser__update_percent_limit(struct hist_browser *hb,/* force to re-evaluate folding state of callchains */ he->init_have_children = false; -hist_entry__set_folding (he, false); +hist_entry__set_folding (he, hb, false); nd =rb_next (nd); }
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists browser: Support collapsing/expanding whole entries in hierarchy
perf hists browser: Support collapsing/expanding whole entries in hierarchy
Commit-ID: 492b1010606e9222690992ad8e4898a88a696856 Gitweb: http://git.kernel.org/tip/492b1010606e9222690992ad8e4898a88a696856 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:44 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:13 -0300
perf hists browser: Support collapsing/expanding whole entries in hierarchy
The 'C' and 'E' keys are to collapse/expand all hist entries. Update nr_hierarchy_entries properly in this case.
--- tools/perf/ui/browsers/hists.c | 58 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 48 insertions(+), 10 deletions(-)
tools/perf/ui/browsers/hists.c +48 -10
@@ -484,13 +484,38 @@ static int callchain__set_folding(struct rb_root *chain, bool unfold)return n; } -static void hist_entry__set_folding (struct hist_entry *he,bool unfold) +static int hierarchy_set_folding (struct hist_browser *hb,struct hist_entry *he, +bool unfold__maybe_unused ) +{ +float percent; +struct rb_node *nd; +struct hist_entry *child; +int n =0 ; + +for (nd =rb_first (&he->hroot_out); nd; nd =rb_next (nd)) { + child = rb_entry(nd, struct hist_entry, rb_node); + percent =hist_entry__get_percent_limit (child); +if (!child->filtered && percent >= hb->min_pcnt) + n++; + } + +return n; +} + +static void hist_entry__set_folding (struct hist_entry *he, +struct hist_browser *hb,bool unfold) {hist_entry__init_have_children (he); he->unfolded = unfold ? he->has_children : false;if (he->has_children) { -int n =callchain__set_folding (&he->sorted_chain, unfold); +int n; + +if (he->leaf) + n =callchain__set_folding (&he->sorted_chain, unfold); +else + n =hierarchy_set_folding (hb, he, unfold); + he->nr_rows = unfold ? n :0 ; }else he->nr_rows =0 ;
@@ -500,19 +525,32 @@ static void __hist_browser__set_folding(struct hist_browser *browser, bool unfold) {struct rb_node *nd; -struct hists *hists = browser->hists; +struct hist_entry *he; +double percent; -for (nd =rb_first (&hists->entries); - (nd =hists__filter_entries (nd, browser->min_pcnt)) !=NULL ; - nd =rb_next (nd)) { - struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node); -hist_entry__set_folding (he, unfold); - browser->nr_callchain_rows += he->nr_rows; + nd =rb_first (&browser->hists->entries); +while (nd) { + he = rb_entry(nd, struct hist_entry, rb_node); + +/* set folding state even if it's currently folded */ + nd =__rb_hierarchy_next (nd,HMD_FORCE_CHILD ); + +hist_entry__set_folding (he, browser, unfold); + + percent =hist_entry__get_percent_limit (he); +if (he->filtered || percent < browser->min_pcnt) +continue ; + +if (!he->depth || unfold) + browser->nr_hierarchy_entries++; +if (he->leaf) + browser->nr_callchain_rows += he->nr_rows; } }static void hist_browser__set_folding (struct hist_browser *browser,bool unfold) { + browser->nr_hierarchy_entries =0 ; browser->nr_callchain_rows =0 ;__hist_browser__set_folding (browser, unfold);
@@ -2131,7 +2169,7 @@ static void hist_browser__update_percent_limit(struct hist_browser *hb,/* force to re-evaluate folding state of callchains */ he->init_have_children = false; -hist_entry__set_folding (he, false); +hist_entry__set_folding (he, hb, false); nd =rb_next (nd); }
Namhyung Kim
maintainerPATCH v7 13/18 perf hists browser: Implement hierarchy output
In reply to Namhyung KimImplement hierarchy mode in TUI. The output is look like stdio but it also supports to fold/unfold children dynamically.
--- tools/perf/ui/browsers/hists.c | 290 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 268 insertions(+), 22 deletions(-)
tools/perf/ui/browsers/hists.c +268 -22
@@ -1260,6 +1260,158 @@ static int hist_browser__show_entry(struct hist_browser *browser,return printed; } +static int hist_browser__show_hierarchy_entry (struct hist_browser *browser, +struct hist_entry *entry, +unsigned short row, +int level,int nr_sort_keys) +{ +int printed =0 ; +int width = browser->b.width; +char folded_sign =' ' ; +bool current_entry =ui_browser__is_current_entry (&browser->b, row); +off_t row_offset = entry->row_offset; +bool first = true; +struct perf_hpp_fmt *fmt; +struct hpp_arg arg = { + .b = &browser->b, + .current_entry = current_entry, + }; +int column =0 ; +int hierarchy_indent = (nr_sort_keys -1 ) *HIERARCHY_INDENT ; + +if (current_entry) { + browser->he_selection = entry; + browser->selection = &entry->ms; + } + +hist_entry__init_have_children (entry); + folded_sign =hist_entry__folded (entry); + arg.folded_sign = folded_sign; + +if (entry->leaf && row_offset) { + row_offset--; + goto show_callchain; + } + +hist_browser__gotorc (browser, row,0 ); + +if (current_entry && browser->b.navkeypressed) +ui_browser__set_color (&browser->b,HE_COLORSET_SELECTED ); +else +ui_browser__set_color (&browser->b,HE_COLORSET_NORMAL ); + +ui_browser__write_nstring (&browser->b,"" , level *HIERARCHY_INDENT ); + width -= level *HIERARCHY_INDENT ; + +hists__for_each_format (entry->hists, fmt) { +char s[2048 ]; +struct perf_hpp hpp = { + .buf = s, + .size =sizeof (s), + .ptr = &arg, + }; + +if (perf_hpp__should_skip (fmt, entry->hists) || + column++ < browser->b.horiz_scroll) +continue ; + +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (current_entry && browser->b.navkeypressed) { +ui_browser__set_color (&browser->b, +HE_COLORSET_SELECTED ); + }else { +ui_browser__set_color (&browser->b, +HE_COLORSET_NORMAL ); + } + +if (first) { +ui_browser__printf (&browser->b,"%c" , folded_sign); + width--; + first = false; + }else { +ui_browser__printf (&browser->b," " ); + width -=2 ; + } + +if (fmt->color) { +int ret = fmt->color (fmt, &hpp, entry); +hist_entry__snprintf_alignment (entry, &hpp, fmt, ret); +/* +* fmt->color() already used ui_browser to +* print the non alignment bits, skip it (+ret): +*/ +ui_browser__printf (&browser->b,"%s" , s + ret); + }else { +int ret = fmt->entry (fmt, &hpp, entry); +hist_entry__snprintf_alignment (entry, &hpp, fmt, ret); +ui_browser__printf (&browser->b,"%s" , s); + } + width -= hpp.buf - s; + } + +ui_browser__write_nstring (&browser->b,"" , hierarchy_indent); + width -= hierarchy_indent; + +if (column >= browser->b.horiz_scroll) { +char s[2048 ]; +struct perf_hpp hpp = { + .buf = s, + .size =sizeof (s), + .ptr = &arg, + }; + +if (current_entry && browser->b.navkeypressed) { +ui_browser__set_color (&browser->b, +HE_COLORSET_SELECTED ); + }else { +ui_browser__set_color (&browser->b, +HE_COLORSET_NORMAL ); + } + +ui_browser__write_nstring (&browser->b,"" ,2 ); + width -=2 ; + +/* +* No need to call hist_entry__snprintf_alignment() +* since this fmt is always the last column in the +* hierarchy mode. +*/ + fmt = entry->fmt; +if (fmt->color) { + width -= fmt->color (fmt, &hpp, entry); + }else { + width -= fmt->entry (fmt, &hpp, entry); +ui_browser__printf (&browser->b,"%s" , s); + } + } + +/* The scroll bar isn't being used */ +if (!browser->b.navkeypressed) + width +=1 ; + +ui_browser__write_nstring (&browser->b,"" , width); + + ++row; + ++printed; + +show_callchain: +if (entry->leaf && folded_sign =='-' && row != browser->b.rows) { +struct callchain_print_arg carg = { + .row_offset = row_offset, + }; + + printed +=hist_browser__show_callchain (browser, entry, + level +1 , row, + hist_browser__show_callchain_entry, &carg, + hist_browser__check_output_full); + } + +return printed; +} +static int advance_hpp_check (struct perf_hpp *hpp,int inc) {advance_hpp (hpp, inc);
@@ -1325,6 +1477,7 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser)u16 header_offset =0 ;struct rb_node *nd; struct hist_browser *hb = container_of(browser, struct hist_browser, b); +int nr_sort = hb->hists->hpp_list->nr_sort_keys;if (hb->show_headers) {hist_browser__show_headers (hb);
@@ -1335,18 +1488,28 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser) hb->he_selection =NULL ; hb->selection =NULL ; -for (nd = browser->top; nd; nd =rb_next (nd)) { +for (nd = browser->top; nd; nd =rb_hierarchy_next (nd)) { struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);float percent; -if (h->filtered) +if (h->filtered) { +/* let it move to sibling */ + h->unfolded = false;continue ; + } percent =hist_entry__get_percent_limit (h);if (percent < hb->min_pcnt)continue ; - row +=hist_browser__show_entry (hb, h, row); +if (symbol_conf.report_hierarchy) { + row +=hist_browser__show_hierarchy_entry (hb, h, row, + h->depth, + nr_sort); + }else { + row +=hist_browser__show_entry (hb, h, row); + } +if (row == browser->rows)break ; }
@@ -1364,7 +1527,14 @@ static struct rb_node *hists__filter_entries(struct rb_node *nd,if (!h->filtered && percent >= min_pcnt)return nd; - nd =rb_next (nd); +/* +* If it's filtered, its all children also were filtered. +* So move to sibling node. +*/ +if (rb_next (nd)) + nd =rb_next (nd); +else + nd =rb_hierarchy_next (nd); }return NULL ;
@@ -1380,7 +1550,7 @@ static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,if (!h->filtered && percent >= min_pcnt)return nd; - nd =rb_prev (nd); + nd =rb_hierarchy_prev (nd); }return NULL ;
@@ -1410,8 +1580,8 @@ static void ui_browser__hists_seek(struct ui_browser *browser, nd = browser->top; goto do_offset;case SEEK_END : - nd =hists__filter_prev_entries (rb_last (browser->entries), - hb->min_pcnt); + nd =rb_hierarchy_last (rb_last (browser->entries)); + nd =hists__filter_prev_entries (nd, hb->min_pcnt); first = false;break ;default :
@@ -1445,7 +1615,7 @@ do_offset:if (offset >0 ) { do { h = rb_entry(nd, struct hist_entry, rb_node); - if (h->unfolded) { + if (h->unfolded && h->leaf) { u16 remaining = h->nr_rows - h->row_offset; if (offset > remaining) { offset -= remaining;
@@ -1457,7 +1627,8 @@ do_offset:break ; } } - nd =hists__filter_entries (rb_next (nd), hb->min_pcnt); + nd =hists__filter_entries (rb_hierarchy_next (nd), + hb->min_pcnt);if (nd ==NULL )break ; --offset;
@@ -1466,7 +1637,7 @@ do_offset: }else if (offset <0 ) {while (1 ) { h = rb_entry(nd, struct hist_entry, rb_node); -if (h->unfolded) { +if (h->unfolded && h->leaf) {if (first) {if (-offset > h->row_offset) { offset += h->row_offset;
@@ -1490,7 +1661,7 @@ do_offset: } } - nd =hists__filter_prev_entries (rb_prev (nd), + nd =hists__filter_prev_entries (rb_hierarchy_prev (nd), hb->min_pcnt);if (nd ==NULL )break ;
@@ -1503,7 +1674,7 @@ do_offset:* row_offset at its last entry. */ h = rb_entry(nd, struct hist_entry, rb_node); -if (h->unfolded) +if (h->unfolded && h->leaf) h->row_offset = h->nr_rows;break ; }
@@ -1517,13 +1688,14 @@ do_offset: }static int hist_browser__fprintf_callchain (struct hist_browser *browser, -struct hist_entry *he,FILE *fp) +struct hist_entry *he,FILE *fp, +int level) {struct callchain_print_arg arg = { .fp = fp, }; -hist_browser__show_callchain (browser, he,1 ,0 , +hist_browser__show_callchain (browser, he, level,0 , hist_browser__fprintf_callchain_entry, &arg, hist_browser__check_dump_full);return arg.printed;
@@ -1566,7 +1738,65 @@ static int hist_browser__fprintf_entry(struct hist_browser *browser, printed +=fprintf (fp,"%s\n" , s);if (folded_sign =='-' ) - printed +=hist_browser__fprintf_callchain (browser, he, fp); + printed +=hist_browser__fprintf_callchain (browser, he, fp,1 ); + +return printed; +} + + +static int hist_browser__fprintf_hierarchy_entry (struct hist_browser *browser, +struct hist_entry *he, +FILE *fp,int level, +int nr_sort_keys) +{ +char s[8192 ]; +int printed =0 ; +char folded_sign =' ' ; +struct perf_hpp hpp = { + .buf = s, + .size =sizeof (s), + }; +struct perf_hpp_fmt *fmt; +bool first = true; +int ret; +int hierarchy_indent = (nr_sort_keys +1 ) *HIERARCHY_INDENT ; + + printed =fprintf (fp,"%*s" , level *HIERARCHY_INDENT ,"" ); + + folded_sign =hist_entry__folded (he); + printed +=fprintf (fp,"%c" , folded_sign); + +hists__for_each_format (he->hists, fmt) { +if (perf_hpp__should_skip (fmt, he->hists)) +continue ; + +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (!first) { + ret =scnprintf (hpp.buf, hpp.size," " ); +advance_hpp (&hpp, ret); + }else + first = false; + + ret = fmt->entry (fmt, &hpp, he); +advance_hpp (&hpp, ret); + } + + ret =scnprintf (hpp.buf, hpp.size,"%*s" , hierarchy_indent,"" ); +advance_hpp (&hpp, ret); + + fmt = he->fmt; + ret = fmt->entry (fmt, &hpp, he); +advance_hpp (&hpp, ret); + + printed +=fprintf (fp,"%s\n" ,rtrim (s)); + +if (he->leaf && folded_sign =='-' ) { + printed +=hist_browser__fprintf_callchain (browser, he, fp, + he->depth +1 ); + }return printed; }
@@ -1576,12 +1806,22 @@ static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)struct rb_node *nd =hists__filter_entries (rb_first (browser->b.entries), browser->min_pcnt);int printed =0 ; +int nr_sort = browser->hists->hpp_list->nr_sort_keys;while (nd) { struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); - printed +=hist_browser__fprintf_entry (browser, h, fp); - nd =hists__filter_entries (rb_next (nd), browser->min_pcnt); +if (symbol_conf.report_hierarchy) { + printed +=hist_browser__fprintf_hierarchy_entry (browser, + h, fp, + h->depth, + nr_sort); + }else { + printed +=hist_browser__fprintf_entry (browser, h, fp); + } + + nd =hists__filter_entries (rb_hierarchy_next (nd), + browser->min_pcnt); }return printed;
@@ -2149,12 +2389,12 @@ static void hist_browser__update_percent_limit(struct hist_browser *hb, hb->min_pcnt = callchain_param.min_percent = percent; -if (!symbol_conf.use_callchain) -return ; -while ((nd =hists__filter_entries (nd, hb->min_pcnt)) !=NULL ) { he = rb_entry(nd, struct hist_entry, rb_node); +if (!he->leaf || !symbol_conf.use_callchain) + goto next; +if (callchain_param.mode ==CHAIN_GRAPH_REL ) { total = he->stat.period;
@@ -2167,11 +2407,17 @@ static void hist_browser__update_percent_limit(struct hist_browser *hb, callchain_param.sort (&he->sorted_chain, he->callchain, min_callchain_hits, &callchain_param); +next: +/* +* Tentatively set unfolded so that the rb_hierarchy_next() +* can toggle children of folded entries too. +*/ + he->unfolded = he->has_children; + nd =rb_hierarchy_next (nd); +/* force to re-evaluate folding state of callchains */ he->init_have_children = false;hist_entry__set_folding (he, hb, false); - - nd =rb_next (nd); } }
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists browser: Implement hierarchy output
perf hists browser: Implement hierarchy output
Commit-ID: d0506edbec7d04dcca632fddfc162faa78d5527a Gitweb: http://git.kernel.org/tip/d0506edbec7d04dcca632fddfc162faa78d5527a Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:45 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:13 -0300
perf hists browser: Implement hierarchy output
Implement hierarchy mode in TUI. The output is look like stdio but it also supports to fold/unfold children dynamically.
--- tools/perf/ui/browsers/hists.c | 290 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 268 insertions(+), 22 deletions(-)
tools/perf/ui/browsers/hists.c +268 -22
@@ -1260,6 +1260,158 @@ static int hist_browser__show_entry(struct hist_browser *browser,return printed; } +static int hist_browser__show_hierarchy_entry (struct hist_browser *browser, +struct hist_entry *entry, +unsigned short row, +int level,int nr_sort_keys) +{ +int printed =0 ; +int width = browser->b.width; +char folded_sign =' ' ; +bool current_entry =ui_browser__is_current_entry (&browser->b, row); +off_t row_offset = entry->row_offset; +bool first = true; +struct perf_hpp_fmt *fmt; +struct hpp_arg arg = { + .b = &browser->b, + .current_entry = current_entry, + }; +int column =0 ; +int hierarchy_indent = (nr_sort_keys -1 ) *HIERARCHY_INDENT ; + +if (current_entry) { + browser->he_selection = entry; + browser->selection = &entry->ms; + } + +hist_entry__init_have_children (entry); + folded_sign =hist_entry__folded (entry); + arg.folded_sign = folded_sign; + +if (entry->leaf && row_offset) { + row_offset--; + goto show_callchain; + } + +hist_browser__gotorc (browser, row,0 ); + +if (current_entry && browser->b.navkeypressed) +ui_browser__set_color (&browser->b,HE_COLORSET_SELECTED ); +else +ui_browser__set_color (&browser->b,HE_COLORSET_NORMAL ); + +ui_browser__write_nstring (&browser->b,"" , level *HIERARCHY_INDENT ); + width -= level *HIERARCHY_INDENT ; + +hists__for_each_format (entry->hists, fmt) { +char s[2048 ]; +struct perf_hpp hpp = { + .buf = s, + .size =sizeof (s), + .ptr = &arg, + }; + +if (perf_hpp__should_skip (fmt, entry->hists) || + column++ < browser->b.horiz_scroll) +continue ; + +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (current_entry && browser->b.navkeypressed) { +ui_browser__set_color (&browser->b, +HE_COLORSET_SELECTED ); + }else { +ui_browser__set_color (&browser->b, +HE_COLORSET_NORMAL ); + } + +if (first) { +ui_browser__printf (&browser->b,"%c" , folded_sign); + width--; + first = false; + }else { +ui_browser__printf (&browser->b," " ); + width -=2 ; + } + +if (fmt->color) { +int ret = fmt->color (fmt, &hpp, entry); +hist_entry__snprintf_alignment (entry, &hpp, fmt, ret); +/* +* fmt->color() already used ui_browser to +* print the non alignment bits, skip it (+ret): +*/ +ui_browser__printf (&browser->b,"%s" , s + ret); + }else { +int ret = fmt->entry (fmt, &hpp, entry); +hist_entry__snprintf_alignment (entry, &hpp, fmt, ret); +ui_browser__printf (&browser->b,"%s" , s); + } + width -= hpp.buf - s; + } + +ui_browser__write_nstring (&browser->b,"" , hierarchy_indent); + width -= hierarchy_indent; + +if (column >= browser->b.horiz_scroll) { +char s[2048 ]; +struct perf_hpp hpp = { + .buf = s, + .size =sizeof (s), + .ptr = &arg, + }; + +if (current_entry && browser->b.navkeypressed) { +ui_browser__set_color (&browser->b, +HE_COLORSET_SELECTED ); + }else { +ui_browser__set_color (&browser->b, +HE_COLORSET_NORMAL ); + } + +ui_browser__write_nstring (&browser->b,"" ,2 ); + width -=2 ; + +/* +* No need to call hist_entry__snprintf_alignment() +* since this fmt is always the last column in the +* hierarchy mode. +*/ + fmt = entry->fmt; +if (fmt->color) { + width -= fmt->color (fmt, &hpp, entry); + }else { + width -= fmt->entry (fmt, &hpp, entry); +ui_browser__printf (&browser->b,"%s" , s); + } + } + +/* The scroll bar isn't being used */ +if (!browser->b.navkeypressed) + width +=1 ; + +ui_browser__write_nstring (&browser->b,"" , width); + + ++row; + ++printed; + +show_callchain: +if (entry->leaf && folded_sign =='-' && row != browser->b.rows) { +struct callchain_print_arg carg = { + .row_offset = row_offset, + }; + + printed +=hist_browser__show_callchain (browser, entry, + level +1 , row, + hist_browser__show_callchain_entry, &carg, + hist_browser__check_output_full); + } + +return printed; +} +static int advance_hpp_check (struct perf_hpp *hpp,int inc) {advance_hpp (hpp, inc);
@@ -1325,6 +1477,7 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser)u16 header_offset =0 ;struct rb_node *nd; struct hist_browser *hb = container_of(browser, struct hist_browser, b); +int nr_sort = hb->hists->hpp_list->nr_sort_keys;if (hb->show_headers) {hist_browser__show_headers (hb);
@@ -1335,18 +1488,28 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser) hb->he_selection =NULL ; hb->selection =NULL ; -for (nd = browser->top; nd; nd =rb_next (nd)) { +for (nd = browser->top; nd; nd =rb_hierarchy_next (nd)) { struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);float percent; -if (h->filtered) +if (h->filtered) { +/* let it move to sibling */ + h->unfolded = false;continue ; + } percent =hist_entry__get_percent_limit (h);if (percent < hb->min_pcnt)continue ; - row +=hist_browser__show_entry (hb, h, row); +if (symbol_conf.report_hierarchy) { + row +=hist_browser__show_hierarchy_entry (hb, h, row, + h->depth, + nr_sort); + }else { + row +=hist_browser__show_entry (hb, h, row); + } +if (row == browser->rows)break ; }
@@ -1364,7 +1527,14 @@ static struct rb_node *hists__filter_entries(struct rb_node *nd,if (!h->filtered && percent >= min_pcnt)return nd; - nd =rb_next (nd); +/* +* If it's filtered, its all children also were filtered. +* So move to sibling node. +*/ +if (rb_next (nd)) + nd =rb_next (nd); +else + nd =rb_hierarchy_next (nd); }return NULL ;
@@ -1380,7 +1550,7 @@ static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,if (!h->filtered && percent >= min_pcnt)return nd; - nd =rb_prev (nd); + nd =rb_hierarchy_prev (nd); }return NULL ;
@@ -1410,8 +1580,8 @@ static void ui_browser__hists_seek(struct ui_browser *browser, nd = browser->top; goto do_offset;case SEEK_END : - nd =hists__filter_prev_entries (rb_last (browser->entries), - hb->min_pcnt); + nd =rb_hierarchy_last (rb_last (browser->entries)); + nd =hists__filter_prev_entries (nd, hb->min_pcnt); first = false;break ;default :
@@ -1445,7 +1615,7 @@ do_offset:if (offset >0 ) { do { h = rb_entry(nd, struct hist_entry, rb_node); - if (h->unfolded) { + if (h->unfolded && h->leaf) { u16 remaining = h->nr_rows - h->row_offset; if (offset > remaining) { offset -= remaining;
@@ -1457,7 +1627,8 @@ do_offset:break ; } } - nd =hists__filter_entries (rb_next (nd), hb->min_pcnt); + nd =hists__filter_entries (rb_hierarchy_next (nd), + hb->min_pcnt);if (nd ==NULL )break ; --offset;
@@ -1466,7 +1637,7 @@ do_offset: }else if (offset <0 ) {while (1 ) { h = rb_entry(nd, struct hist_entry, rb_node); -if (h->unfolded) { +if (h->unfolded && h->leaf) {if (first) {if (-offset > h->row_offset) { offset += h->row_offset;
@@ -1490,7 +1661,7 @@ do_offset: } } - nd =hists__filter_prev_entries (rb_prev (nd), + nd =hists__filter_prev_entries (rb_hierarchy_prev (nd), hb->min_pcnt);if (nd ==NULL )break ;
@@ -1503,7 +1674,7 @@ do_offset:* row_offset at its last entry. */ h = rb_entry(nd, struct hist_entry, rb_node); -if (h->unfolded) +if (h->unfolded && h->leaf) h->row_offset = h->nr_rows;break ; }
@@ -1517,13 +1688,14 @@ do_offset: }static int hist_browser__fprintf_callchain (struct hist_browser *browser, -struct hist_entry *he,FILE *fp) +struct hist_entry *he,FILE *fp, +int level) {struct callchain_print_arg arg = { .fp = fp, }; -hist_browser__show_callchain (browser, he,1 ,0 , +hist_browser__show_callchain (browser, he, level,0 , hist_browser__fprintf_callchain_entry, &arg, hist_browser__check_dump_full);return arg.printed;
@@ -1566,7 +1738,65 @@ static int hist_browser__fprintf_entry(struct hist_browser *browser, printed +=fprintf (fp,"%s\n" , s);if (folded_sign =='-' ) - printed +=hist_browser__fprintf_callchain (browser, he, fp); + printed +=hist_browser__fprintf_callchain (browser, he, fp,1 ); + +return printed; +} + + +static int hist_browser__fprintf_hierarchy_entry (struct hist_browser *browser, +struct hist_entry *he, +FILE *fp,int level, +int nr_sort_keys) +{ +char s[8192 ]; +int printed =0 ; +char folded_sign =' ' ; +struct perf_hpp hpp = { + .buf = s, + .size =sizeof (s), + }; +struct perf_hpp_fmt *fmt; +bool first = true; +int ret; +int hierarchy_indent = (nr_sort_keys +1 ) *HIERARCHY_INDENT ; + + printed =fprintf (fp,"%*s" , level *HIERARCHY_INDENT ,"" ); + + folded_sign =hist_entry__folded (he); + printed +=fprintf (fp,"%c" , folded_sign); + +hists__for_each_format (he->hists, fmt) { +if (perf_hpp__should_skip (fmt, he->hists)) +continue ; + +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (!first) { + ret =scnprintf (hpp.buf, hpp.size," " ); +advance_hpp (&hpp, ret); + }else + first = false; + + ret = fmt->entry (fmt, &hpp, he); +advance_hpp (&hpp, ret); + } + + ret =scnprintf (hpp.buf, hpp.size,"%*s" , hierarchy_indent,"" ); +advance_hpp (&hpp, ret); + + fmt = he->fmt; + ret = fmt->entry (fmt, &hpp, he); +advance_hpp (&hpp, ret); + + printed +=fprintf (fp,"%s\n" ,rtrim (s)); + +if (he->leaf && folded_sign =='-' ) { + printed +=hist_browser__fprintf_callchain (browser, he, fp, + he->depth +1 ); + }return printed; }
@@ -1576,12 +1806,22 @@ static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)struct rb_node *nd =hists__filter_entries (rb_first (browser->b.entries), browser->min_pcnt);int printed =0 ; +int nr_sort = browser->hists->hpp_list->nr_sort_keys;while (nd) { struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); - printed +=hist_browser__fprintf_entry (browser, h, fp); - nd =hists__filter_entries (rb_next (nd), browser->min_pcnt); +if (symbol_conf.report_hierarchy) { + printed +=hist_browser__fprintf_hierarchy_entry (browser, + h, fp, + h->depth, + nr_sort); + }else { + printed +=hist_browser__fprintf_entry (browser, h, fp); + } + + nd =hists__filter_entries (rb_hierarchy_next (nd), + browser->min_pcnt); }return printed;
@@ -2149,12 +2389,12 @@ static void hist_browser__update_percent_limit(struct hist_browser *hb, hb->min_pcnt = callchain_param.min_percent = percent; -if (!symbol_conf.use_callchain) -return ; -while ((nd =hists__filter_entries (nd, hb->min_pcnt)) !=NULL ) { he = rb_entry(nd, struct hist_entry, rb_node); +if (!he->leaf || !symbol_conf.use_callchain) + goto next; +if (callchain_param.mode ==CHAIN_GRAPH_REL ) { total = he->stat.period;
@@ -2167,11 +2407,17 @@ static void hist_browser__update_percent_limit(struct hist_browser *hb, callchain_param.sort (&he->sorted_chain, he->callchain, min_callchain_hits, &callchain_param); +next: +/* +* Tentatively set unfolded so that the rb_hierarchy_next() +* can toggle children of folded entries too. +*/ + he->unfolded = he->has_children; + nd =rb_hierarchy_next (nd); +/* force to re-evaluate folding state of callchains */ he->init_have_children = false;hist_entry__set_folding (he, hb, false); - - nd =rb_next (nd); } }
Namhyung Kim
maintainerPATCH v7 14/18 perf hists browser: Align column header in hierarchy mode
In reply to Namhyung KimLike in stdio, fit column header to hierarchy output. Merge column headers with "/" as a separator.
Overhead Command / Shared Object / Symbol
...
+ 0.09% dwm + 0.06% emacs - 0.05% perf
- 0.05% [kernel.vmlinux]
+ 0.03% [k] memcpy_orig
+ 0.01% [k] unmap_single_vma
+ 0.01% [k] smp_call_function_single
+ 0.00% [k] native_irq_return_iret
+ 0.00% [k] arch_trigger_all_cpu_backtrace_handler
+ 0.00% [k] native_write_msr_safe
--- tools/perf/ui/browsers/hists.c | 71 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 70 insertions(+), 1 deletion(-)
tools/perf/ui/browsers/hists.c +70 -1
@@ -1451,11 +1451,80 @@ static int hists_browser__scnprintf_headers(struct hist_browser *browser, char *return ret; } +static int hists_browser__scnprintf_hierarchy_headers (struct hist_browser *browser,char *buf,size_t size) +{ +struct hists *hists = browser->hists; +struct perf_hpp dummy_hpp = { + .buf = buf, + .size = size, + }; +struct perf_hpp_fmt *fmt; +size_t ret =0 ; +int column =0 ; +int nr_sort_keys = hists->hpp_list->nr_sort_keys; +bool first = true; + + ret =scnprintf (buf, size," " ); +if (advance_hpp_check (&dummy_hpp, ret)) +return ret; + +hists__for_each_format (hists, fmt) { +if (column++ < browser->b.horiz_scroll) +continue ; + +if (perf_hpp__is_sort_entry (fmt) ||perf_hpp__is_dynamic_entry (fmt)) +break ; + + ret = fmt->header (fmt, &dummy_hpp,hists_to_evsel (hists)); +if (advance_hpp_check (&dummy_hpp, ret)) +break ; + + ret =scnprintf (dummy_hpp.buf, dummy_hpp.size," " ); +if (advance_hpp_check (&dummy_hpp, ret)) +break ; + } + + ret =scnprintf (dummy_hpp.buf, dummy_hpp.size,"%*s" , + (nr_sort_keys -1 ) *HIERARCHY_INDENT ,"" ); +if (advance_hpp_check (&dummy_hpp, ret)) +return ret; + +hists__for_each_format (hists, fmt) { +if (!perf_hpp__is_sort_entry (fmt) && !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + +if (first) { + first = false; + }else { + ret =scnprintf (dummy_hpp.buf, dummy_hpp.size," / " ); +if (advance_hpp_check (&dummy_hpp, ret)) +break ; + } + + ret = fmt->header (fmt, &dummy_hpp,hists_to_evsel (hists)); + dummy_hpp.buf[ret] ='\0' ; +rtrim (dummy_hpp.buf); + + ret =strlen (dummy_hpp.buf); +if (advance_hpp_check (&dummy_hpp, ret)) +break ; + } + +return ret; +} +static void hist_browser__show_headers (struct hist_browser *browser) {char headers[1024 ]; -hists_browser__scnprintf_headers (browser, headers,sizeof (headers)); +if (symbol_conf.report_hierarchy) +hists_browser__scnprintf_hierarchy_headers (browser, headers, +sizeof (headers)); +else +hists_browser__scnprintf_headers (browser, headers, +sizeof (headers));ui_browser__gotorc (&browser->b,0 ,0 );ui_browser__set_color (&browser->b,HE_COLORSET_ROOT );ui_browser__write_nstring (&browser->b, headers, browser->b.width +1 );
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists browser: Align column header in hierarchy mode
perf hists browser: Align column header in hierarchy mode
Commit-ID: d8b92400d3ba6bb9a310c42b7518a81eb90f83be Gitweb: http://git.kernel.org/tip/d8b92400d3ba6bb9a310c42b7518a81eb90f83be Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:46 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:14 -0300
perf hists browser: Align column header in hierarchy mode
Like in stdio, fit column header to hierarchy output. Merge column headers with "/" as a separator.
Overhead Command / Shared Object / Symbol
...
+ 0.09% dwm + 0.06% emacs - 0.05% perf
- 0.05% [kernel.vmlinux]
+ 0.03% [k] memcpy_orig
+ 0.01% [k] unmap_single_vma
+ 0.01% [k] smp_call_function_single
+ 0.00% [k] native_irq_return_iret
+ 0.00% [k] arch_trigger_all_cpu_backtrace_handler
+ 0.00% [k] native_write_msr_safe
--- tools/perf/ui/browsers/hists.c | 71 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 70 insertions(+), 1 deletion(-)
tools/perf/ui/browsers/hists.c +70 -1
@@ -1451,11 +1451,80 @@ static int hists_browser__scnprintf_headers(struct hist_browser *browser, char *return ret; } +static int hists_browser__scnprintf_hierarchy_headers (struct hist_browser *browser,char *buf,size_t size) +{ +struct hists *hists = browser->hists; +struct perf_hpp dummy_hpp = { + .buf = buf, + .size = size, + }; +struct perf_hpp_fmt *fmt; +size_t ret =0 ; +int column =0 ; +int nr_sort_keys = hists->hpp_list->nr_sort_keys; +bool first = true; + + ret =scnprintf (buf, size," " ); +if (advance_hpp_check (&dummy_hpp, ret)) +return ret; + +hists__for_each_format (hists, fmt) { +if (column++ < browser->b.horiz_scroll) +continue ; + +if (perf_hpp__is_sort_entry (fmt) ||perf_hpp__is_dynamic_entry (fmt)) +break ; + + ret = fmt->header (fmt, &dummy_hpp,hists_to_evsel (hists)); +if (advance_hpp_check (&dummy_hpp, ret)) +break ; + + ret =scnprintf (dummy_hpp.buf, dummy_hpp.size," " ); +if (advance_hpp_check (&dummy_hpp, ret)) +break ; + } + + ret =scnprintf (dummy_hpp.buf, dummy_hpp.size,"%*s" , + (nr_sort_keys -1 ) *HIERARCHY_INDENT ,"" ); +if (advance_hpp_check (&dummy_hpp, ret)) +return ret; + +hists__for_each_format (hists, fmt) { +if (!perf_hpp__is_sort_entry (fmt) && !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + +if (first) { + first = false; + }else { + ret =scnprintf (dummy_hpp.buf, dummy_hpp.size," / " ); +if (advance_hpp_check (&dummy_hpp, ret)) +break ; + } + + ret = fmt->header (fmt, &dummy_hpp,hists_to_evsel (hists)); + dummy_hpp.buf[ret] ='\0' ; +rtrim (dummy_hpp.buf); + + ret =strlen (dummy_hpp.buf); +if (advance_hpp_check (&dummy_hpp, ret)) +break ; + } + +return ret; +} +static void hist_browser__show_headers (struct hist_browser *browser) {char headers[1024 ]; -hists_browser__scnprintf_headers (browser, headers,sizeof (headers)); +if (symbol_conf.report_hierarchy) +hists_browser__scnprintf_hierarchy_headers (browser, headers, +sizeof (headers)); +else +hists_browser__scnprintf_headers (browser, headers, +sizeof (headers));ui_browser__gotorc (&browser->b,0 ,0 );ui_browser__set_color (&browser->b,HE_COLORSET_ROOT );ui_browser__write_nstring (&browser->b, headers, browser->b.width +1 );
Namhyung Kim
maintainerPATCH v7 15/18 perf ui/gtk: Implement hierarchy output mode
In reply to Namhyung KimThe hierarchy output mode is to group entries for each level so that user can see higher level picture more easily.
--- tools/perf/ui/gtk/hists.c | 163 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 162 insertions(+), 1 deletion(-)
tools/perf/ui/gtk/hists.c +162 -1
@@ -396,6 +396,164 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists,gtk_container_add (GTK_CONTAINER (window), view); } +static void perf_gtk__add_hierarchy_entries (struct hists *hists, +struct rb_root *root, +GtkTreeStore *store, +GtkTreeIter *parent, +struct perf_hpp *hpp, +float min_pcnt) +{ +int col_idx =0 ; +struct rb_node *node; +struct hist_entry *he; +struct perf_hpp_fmt *fmt; +u64 total =hists__total_period (hists); + +for (node =rb_first (root); node; node =rb_next (node)) { +GtkTreeIter iter; +float percent; + + he = rb_entry(node, struct hist_entry, rb_node); +if (he->filtered) +continue ; + + percent =hist_entry__get_percent_limit (he); +if (percent < min_pcnt) +continue ; + +gtk_tree_store_append (store, &iter, parent); + + col_idx =0 ; +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (fmt->color) + fmt->color (fmt, hpp, he); +else + fmt->entry (fmt, hpp, he); + +gtk_tree_store_set (store, &iter, col_idx++, hpp->buf,-1 ); + } + + fmt = he->fmt; +if (fmt->color) + fmt->color (fmt, hpp, he); +else + fmt->entry (fmt, hpp, he); + +gtk_tree_store_set (store, &iter, col_idx,rtrim (hpp->buf),-1 ); + +if (!he->leaf) { +perf_gtk__add_hierarchy_entries (hists, &he->hroot_out, + store, &iter, hpp, + min_pcnt); + } + +if (symbol_conf.use_callchain && he->leaf) { +if (callchain_param.mode ==CHAIN_GRAPH_REL ) + total = symbol_conf.cumulate_callchain ? + he->stat_acc->period : he->stat.period; + +perf_gtk__add_callchain (&he->sorted_chain, store, &iter, + col_idx, total); + } + } + +} + +static void perf_gtk__show_hierarchy (GtkWidget *window,struct hists *hists, +float min_pcnt) +{ +struct perf_hpp_fmt *fmt; +GType col_types[MAX_COLUMNS ]; +GtkCellRenderer *renderer; +GtkTreeStore *store; +GtkWidget *view; +int col_idx; +int nr_cols =0 ; +char s[512 ]; +char buf[512 ]; +bool first = true; +struct perf_hpp hpp = { + .buf = s, + .size =sizeof (s), + }; + +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + + col_types[nr_cols++] =G_TYPE_STRING ; + } + col_types[nr_cols++] =G_TYPE_STRING ; + + store =gtk_tree_store_newv (nr_cols, col_types); + view =gtk_tree_view_new (); + renderer =gtk_cell_renderer_text_new (); + + col_idx =0 ; +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + +gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), +-1 , fmt->name, + renderer,"markup" , + col_idx++,NULL ); + } + +/* construct merged column header since sort keys share single column */ + buf[0 ] ='\0' ; +hists__for_each_format (hists ,fmt) { +if (!perf_hpp__is_sort_entry (fmt) && + !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + +if (first) + first = false; +else +strcat (buf," / " ); + + fmt->header (fmt, &hpp,hists_to_evsel (hists)); +strcat (buf,rtrim (hpp.buf)); + } + +gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), +-1 , buf, + renderer,"markup" , + col_idx++,NULL ); + +for (col_idx =0 ; col_idx < nr_cols; col_idx++) { +GtkTreeViewColumn *column; + + column =gtk_tree_view_get_column (GTK_TREE_VIEW (view), col_idx); +gtk_tree_view_column_set_resizable (column, TRUE); + +if (col_idx ==0 ) { +gtk_tree_view_set_expander_column (GTK_TREE_VIEW (view), + column); + } + } + +gtk_tree_view_set_model (GTK_TREE_VIEW (view),GTK_TREE_MODEL (store)); +g_object_unref (GTK_TREE_MODEL (store)); + +perf_gtk__add_hierarchy_entries (hists, &hists->entries, store, +NULL , &hpp, min_pcnt); + +gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); + +g_signal_connect (view,"row-activated" , +G_CALLBACK (on_row_activated),NULL ); +gtk_container_add (GTK_CONTAINER (window), view); +} + int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist, const char *help, struct hist_browser_timer *hbt __maybe_unused,
@@ -463,7 +621,10 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,GTK_POLICY_AUTOMATIC , GTK_POLICY_AUTOMATIC); -perf_gtk__show_hists (scrolled_window, hists, min_pcnt); +if (symbol_conf.report_hierarchy) +perf_gtk__show_hierarchy (scrolled_window, hists, min_pcnt); +else +perf_gtk__show_hists (scrolled_window, hists, min_pcnt); tab_label =gtk_label_new (evname);
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf ui/gtk: Implement hierarchy output mode
perf ui/gtk: Implement hierarchy output mode
Commit-ID: e311ec1e5df6d5de377e67f704bca43fb023ca5e Gitweb: http://git.kernel.org/tip/e311ec1e5df6d5de377e67f704bca43fb023ca5e Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:47 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:14 -0300
perf ui/gtk: Implement hierarchy output mode
The hierarchy output mode is to group entries for each level so that user can see higher level picture more easily.
--- tools/perf/ui/gtk/hists.c | 163 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 162 insertions(+), 1 deletion(-)
tools/perf/ui/gtk/hists.c +162 -1
@@ -396,6 +396,164 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists,gtk_container_add (GTK_CONTAINER (window), view); } +static void perf_gtk__add_hierarchy_entries (struct hists *hists, +struct rb_root *root, +GtkTreeStore *store, +GtkTreeIter *parent, +struct perf_hpp *hpp, +float min_pcnt) +{ +int col_idx =0 ; +struct rb_node *node; +struct hist_entry *he; +struct perf_hpp_fmt *fmt; +u64 total =hists__total_period (hists); + +for (node =rb_first (root); node; node =rb_next (node)) { +GtkTreeIter iter; +float percent; + + he = rb_entry(node, struct hist_entry, rb_node); +if (he->filtered) +continue ; + + percent =hist_entry__get_percent_limit (he); +if (percent < min_pcnt) +continue ; + +gtk_tree_store_append (store, &iter, parent); + + col_idx =0 ; +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + +if (fmt->color) + fmt->color (fmt, hpp, he); +else + fmt->entry (fmt, hpp, he); + +gtk_tree_store_set (store, &iter, col_idx++, hpp->buf,-1 ); + } + + fmt = he->fmt; +if (fmt->color) + fmt->color (fmt, hpp, he); +else + fmt->entry (fmt, hpp, he); + +gtk_tree_store_set (store, &iter, col_idx,rtrim (hpp->buf),-1 ); + +if (!he->leaf) { +perf_gtk__add_hierarchy_entries (hists, &he->hroot_out, + store, &iter, hpp, + min_pcnt); + } + +if (symbol_conf.use_callchain && he->leaf) { +if (callchain_param.mode ==CHAIN_GRAPH_REL ) + total = symbol_conf.cumulate_callchain ? + he->stat_acc->period : he->stat.period; + +perf_gtk__add_callchain (&he->sorted_chain, store, &iter, + col_idx, total); + } + } + +} + +static void perf_gtk__show_hierarchy (GtkWidget *window,struct hists *hists, +float min_pcnt) +{ +struct perf_hpp_fmt *fmt; +GType col_types[MAX_COLUMNS ]; +GtkCellRenderer *renderer; +GtkTreeStore *store; +GtkWidget *view; +int col_idx; +int nr_cols =0 ; +char s[512 ]; +char buf[512 ]; +bool first = true; +struct perf_hpp hpp = { + .buf = s, + .size =sizeof (s), + }; + +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + + col_types[nr_cols++] =G_TYPE_STRING ; + } + col_types[nr_cols++] =G_TYPE_STRING ; + + store =gtk_tree_store_newv (nr_cols, col_types); + view =gtk_tree_view_new (); + renderer =gtk_cell_renderer_text_new (); + + col_idx =0 ; +hists__for_each_format (hists, fmt) { +if (perf_hpp__is_sort_entry (fmt) || +perf_hpp__is_dynamic_entry (fmt)) +break ; + +gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), +-1 , fmt->name, + renderer,"markup" , + col_idx++,NULL ); + } + +/* construct merged column header since sort keys share single column */ + buf[0 ] ='\0' ; +hists__for_each_format (hists ,fmt) { +if (!perf_hpp__is_sort_entry (fmt) && + !perf_hpp__is_dynamic_entry (fmt)) +continue ; +if (perf_hpp__should_skip (fmt, hists)) +continue ; + +if (first) + first = false; +else +strcat (buf," / " ); + + fmt->header (fmt, &hpp,hists_to_evsel (hists)); +strcat (buf,rtrim (hpp.buf)); + } + +gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), +-1 , buf, + renderer,"markup" , + col_idx++,NULL ); + +for (col_idx =0 ; col_idx < nr_cols; col_idx++) { +GtkTreeViewColumn *column; + + column =gtk_tree_view_get_column (GTK_TREE_VIEW (view), col_idx); +gtk_tree_view_column_set_resizable (column, TRUE); + +if (col_idx ==0 ) { +gtk_tree_view_set_expander_column (GTK_TREE_VIEW (view), + column); + } + } + +gtk_tree_view_set_model (GTK_TREE_VIEW (view),GTK_TREE_MODEL (store)); +g_object_unref (GTK_TREE_MODEL (store)); + +perf_gtk__add_hierarchy_entries (hists, &hists->entries, store, +NULL , &hpp, min_pcnt); + +gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); + +g_signal_connect (view,"row-activated" , +G_CALLBACK (on_row_activated),NULL ); +gtk_container_add (GTK_CONTAINER (window), view); +} + int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist, const char *help, struct hist_browser_timer *hbt __maybe_unused,
@@ -463,7 +621,10 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,GTK_POLICY_AUTOMATIC , GTK_POLICY_AUTOMATIC); -perf_gtk__show_hists (scrolled_window, hists, min_pcnt); +if (symbol_conf.report_hierarchy) +perf_gtk__show_hierarchy (scrolled_window, hists, min_pcnt); +else +perf_gtk__show_hists (scrolled_window, hists, min_pcnt); tab_label =gtk_label_new (evname);
Namhyung Kim
maintainerPATCH v7 16/18 perf report: Add --hierarchy option
In reply to Namhyung KimThe --hierarchy option is to show output in hierarchy mode. It extends folding/unfolding in the TUI and GTK browsers to support sort items as well as callchains. Users can toggle the items to see the performance result at wanted level.
$ perf report --hierarchy --tui
Overhead Command / Shared Object / Symbol
--------------------------------------------------
+ 32.96% gnome-shell
- 15.11% swapper
- 14.97% [kernel.vmlinux]
6.82% [k] intel_idle
0.66% [k] menu_select
0.43% [k] __hrtimer_start_range_ns
...--- tools/perf/Documentation/perf-report.txt | 3 +++ tools/perf/Documentation/tips.txt | 1 + tools/perf/builtin-report.c | 17 +++++++++++++++++ 3 files changed, 21 insertions(+)
tools/perf/Documentation/perf-report.txt +3 -0
@@ -401,6 +401,9 @@ include::itrace.txt[] --raw-trace:: When displaying traceevent output, do not use print fmt or plugins. +--hierarchy:: + Enable hierarchical output. + include::callchain-overhead-calculation.txt[] SEE ALSO
tools/perf/Documentation/tips.txt +1 -0
@@ -27,3 +27,4 @@ Skip collecing build-id when recording: perf record -B To change sampling frequency to 100 Hz: perf record -F 100 See assembly instructions with percentage: perf annotate <symbol> If you prefer Intel style assembly, try: perf annotate -M intel +For hierarchical output, try: perf report --hierarchy
tools/perf/builtin-report.c +17 -0
@@ -811,6 +811,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused) "only show processor socket that match with this filter"),OPT_BOOLEAN (0 ,"raw-trace" , &symbol_conf.raw_trace,"Show raw trace event output (do not use print fmt or plugins)" ), +OPT_BOOLEAN (0 ,"hierarchy" , &symbol_conf.report_hierarchy, +"Show entries in a hierarchy" ),OPT_END () }; struct perf_data_file file = {
@@ -920,6 +922,21 @@ repeat: symbol_conf.cumulate_callchain = false; } +if (symbol_conf.report_hierarchy) { +/* disable incompatible options */ + symbol_conf.event_group = false; + symbol_conf.cumulate_callchain = false; + +if (field_order) { +pr_err ("Error: --hierarchy and --fields options cannot be used together\n" ); +parse_options_usage (report_usage, options,"F" ,1 ); +parse_options_usage (NULL , options,"hierarchy" ,0 ); + goto error; + } + + sort__need_collapse = true; + } +/* Force tty output for header output and per-thread stat. */ if (report.header || report.header_only || report.show_threads) use_browser =0 ;
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf report: Add --hierarchy option
perf report: Add --hierarchy option
Commit-ID: 4251446d778e669db5ac9f86b02d38064bdbbf9a Gitweb: http://git.kernel.org/tip/4251446d778e669db5ac9f86b02d38064bdbbf9a Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:48 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:15 -0300
perf report: Add --hierarchy option
The --hierarchy option is to show output in hierarchy mode. It extends folding/unfolding in the TUI and GTK browsers to support sort items as well as callchains. Users can toggle the items to see the performance result at wanted level.
$ perf report --hierarchy --tui
Overhead Command / Shared Object / Symbol
--------------------------------------------------
+ 32.96% gnome-shell
- 15.11% swapper
- 14.97% [kernel.vmlinux]
6.82% [k] intel_idle
0.66% [k] menu_select
0.43% [k] __hrtimer_start_range_ns
...--- tools/perf/Documentation/perf-report.txt | 3 +++ tools/perf/Documentation/tips.txt | 1 + tools/perf/builtin-report.c | 17 +++++++++++++++++ 3 files changed, 21 insertions(+)
tools/perf/Documentation/perf-report.txt +3 -0
@@ -401,6 +401,9 @@ include::itrace.txt[] --raw-trace:: When displaying traceevent output, do not use print fmt or plugins. +--hierarchy:: + Enable hierarchical output. + include::callchain-overhead-calculation.txt[] SEE ALSO
tools/perf/Documentation/tips.txt +1 -0
@@ -27,3 +27,4 @@ Skip collecing build-id when recording: perf record -B To change sampling frequency to 100 Hz: perf record -F 100 See assembly instructions with percentage: perf annotate <symbol> If you prefer Intel style assembly, try: perf annotate -M intel +For hierarchical output, try: perf report --hierarchy
tools/perf/builtin-report.c +17 -0
@@ -811,6 +811,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused) "only show processor socket that match with this filter"),OPT_BOOLEAN (0 ,"raw-trace" , &symbol_conf.raw_trace,"Show raw trace event output (do not use print fmt or plugins)" ), +OPT_BOOLEAN (0 ,"hierarchy" , &symbol_conf.report_hierarchy, +"Show entries in a hierarchy" ),OPT_END () }; struct perf_data_file file = {
@@ -920,6 +922,21 @@ repeat: symbol_conf.cumulate_callchain = false; } +if (symbol_conf.report_hierarchy) { +/* disable incompatible options */ + symbol_conf.event_group = false; + symbol_conf.cumulate_callchain = false; + +if (field_order) { +pr_err ("Error: --hierarchy and --fields options cannot be used together\n" ); +parse_options_usage (report_usage, options,"F" ,1 ); +parse_options_usage (NULL , options,"hierarchy" ,0 ); + goto error; + } + + sort__need_collapse = true; + } +/* Force tty output for header output and per-thread stat. */ if (report.header || report.header_only || report.show_threads) use_browser =0 ;
Namhyung Kim
maintainerPATCH v7 17/18 perf hists: Support decaying in hierarchy mode
In reply to Namhyung KimIn the hierarchy mode, hist entries should decay their children too. Also update hists__delete_entry() to be able to free child entries.
--- tools/perf/util/hist.c | 42 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 34 insertions(+), 8 deletions(-)
tools/perf/util/hist.c +34 -8
@@ -248,6 +248,8 @@ static void he_stat__decay(struct he_stat *he_stat)/* XXX need decay for weight too? */ } +static void hists__delete_entry (struct hists *hists,struct hist_entry *he); +static bool hists__decay_entry (struct hists *hists,struct hist_entry *he) {u64 prev_period = he->stat.period;
@@ -263,21 +265,45 @@ static bool hists__decay_entry(struct hists *hists, struct hist_entry *he) diff = prev_period - he->stat.period; - hists->stats.total_period -= diff; -if (!he->filtered) - hists->stats.total_non_filtered_period -= diff; +if (!he->depth) { + hists->stats.total_period -= diff; +if (!he->filtered) + hists->stats.total_non_filtered_period -= diff; + } + +if (!he->leaf) { +struct hist_entry *child; +struct rb_node *node =rb_first (&he->hroot_out); +while (node) { + child = rb_entry(node, struct hist_entry, rb_node); + node =rb_next (node); + +if (hists__decay_entry (hists, child)) +hists__delete_entry (hists, child); + } + }return he->stat.period ==0 ; }static void hists__delete_entry (struct hists *hists,struct hist_entry *he) { -rb_erase (&he->rb_node, &hists->entries); +struct rb_root *root_in; +struct rb_root *root_out; -if (sort__need_collapse) -rb_erase (&he->rb_node_in, &hists->entries_collapsed); -else -rb_erase (&he->rb_node_in, hists->entries_in); +if (he->parent_he) { + root_in = &he->parent_he->hroot_in; + root_out = &he->parent_he->hroot_out; + }else { +if (sort__need_collapse) + root_in = &hists->entries_collapsed; +else + root_in = hists->entries_in; + root_out = &hists->entries; + } + +rb_erase (&he->rb_node_in, root_in); +rb_erase (&he->rb_node, root_out); --hists->nr_entries;if (!he->filtered)
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf hists: Support decaying in hierarchy mode
perf hists: Support decaying in hierarchy mode
Commit-ID: 5d8200ae67724960f7761b3a2216a1ca651fcc65 Gitweb: http://git.kernel.org/tip/5d8200ae67724960f7761b3a2216a1ca651fcc65 Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:49 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:15 -0300
perf hists: Support decaying in hierarchy mode
In the hierarchy mode, hist entries should decay their children too. Also update hists__delete_entry() to be able to free child entries.
--- tools/perf/util/hist.c | 42 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 34 insertions(+), 8 deletions(-)
tools/perf/util/hist.c +34 -8
@@ -248,6 +248,8 @@ static void he_stat__decay(struct he_stat *he_stat)/* XXX need decay for weight too? */ } +static void hists__delete_entry (struct hists *hists,struct hist_entry *he); +static bool hists__decay_entry (struct hists *hists,struct hist_entry *he) {u64 prev_period = he->stat.period;
@@ -263,21 +265,45 @@ static bool hists__decay_entry(struct hists *hists, struct hist_entry *he) diff = prev_period - he->stat.period; - hists->stats.total_period -= diff; -if (!he->filtered) - hists->stats.total_non_filtered_period -= diff; +if (!he->depth) { + hists->stats.total_period -= diff; +if (!he->filtered) + hists->stats.total_non_filtered_period -= diff; + } + +if (!he->leaf) { +struct hist_entry *child; +struct rb_node *node =rb_first (&he->hroot_out); +while (node) { + child = rb_entry(node, struct hist_entry, rb_node); + node =rb_next (node); + +if (hists__decay_entry (hists, child)) +hists__delete_entry (hists, child); + } + }return he->stat.period ==0 ; }static void hists__delete_entry (struct hists *hists,struct hist_entry *he) { -rb_erase (&he->rb_node, &hists->entries); +struct rb_root *root_in; +struct rb_root *root_out; -if (sort__need_collapse) -rb_erase (&he->rb_node_in, &hists->entries_collapsed); -else -rb_erase (&he->rb_node_in, hists->entries_in); +if (he->parent_he) { + root_in = &he->parent_he->hroot_in; + root_out = &he->parent_he->hroot_out; + }else { +if (sort__need_collapse) + root_in = &hists->entries_collapsed; +else + root_in = hists->entries_in; + root_out = &hists->entries; + } + +rb_erase (&he->rb_node_in, root_in); +rb_erase (&he->rb_node, root_out); --hists->nr_entries;if (!he->filtered)
Namhyung Kim
maintainerPATCH v7 18/18 perf top: Add --hierarchy option
In reply to Namhyung KimSupport hierarchy output for perf-top using --hierarchy option.
--- tools/perf/Documentation/perf-top.txt | 3 +++ tools/perf/builtin-top.c | 15 +++++++++++++++ 2 files changed, 18 insertions(+)
tools/perf/Documentation/perf-top.txt +3 -0
@@ -233,6 +233,9 @@ Default is to monitor all CPUS. --raw-trace:: When displaying traceevent output, do not use print fmt or plugins. +--hierarchy:: + Enable hierarchy output. + INTERACTIVE PROMPTING KEYS --------------------------
tools/perf/builtin-top.c +15 -0
@@ -1214,6 +1214,8 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused) parse_branch_stack),OPT_BOOLEAN (0 ,"raw-trace" , &symbol_conf.raw_trace,"Show raw trace event output (do not use print fmt or plugins)" ), +OPT_BOOLEAN (0 ,"hierarchy" , &symbol_conf.report_hierarchy, +"Show entries in a hierarchy" ),OPT_END () }; const char * const top_usage[] = {
@@ -1241,6 +1243,19 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused) goto out_delete_evlist; } +if (symbol_conf.report_hierarchy) { +/* disable incompatible options */ + symbol_conf.event_group = false; + symbol_conf.cumulate_callchain = false; + +if (field_order) { +pr_err ("Error: --hierarchy and --fields options cannot be used together\n" ); +parse_options_usage (top_usage, options,"fields" ,0 ); +parse_options_usage (NULL , options,"hierarchy" ,0 ); + goto out_delete_evlist; + } + } + sort__mode =SORT_MODE__TOP ;/* display thread wants entries to be collapsed in a different tree */ sort__need_collapse =1 ;
Signature · 1 line
2.7.1
tip-bot for Namhyung Kim
merge bot[tip:perf/core] perf top: Add --hierarchy option
perf top: Add --hierarchy option
Commit-ID: c92fcfde3486fb4b9e476ee5ad5995a62e401cce Gitweb: http://git.kernel.org/tip/c92fcfde3486fb4b9e476ee5ad5995a62e401cce Author: Namhyung Kim <[email protected]> AuthorDate: Thu, 25 Feb 2016 00:13:50 +0900 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Wed, 24 Feb 2016 20:21:15 -0300
perf top: Add --hierarchy option
Support hierarchy output for perf-top using --hierarchy option.
--- tools/perf/Documentation/perf-top.txt | 3 +++ tools/perf/builtin-top.c | 15 +++++++++++++++ 2 files changed, 18 insertions(+)
tools/perf/Documentation/perf-top.txt +3 -0
@@ -233,6 +233,9 @@ Default is to monitor all CPUS. --raw-trace:: When displaying traceevent output, do not use print fmt or plugins. +--hierarchy:: + Enable hierarchy output. + INTERACTIVE PROMPTING KEYS --------------------------
tools/perf/builtin-top.c +15 -0
@@ -1214,6 +1214,8 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused) parse_branch_stack),OPT_BOOLEAN (0 ,"raw-trace" , &symbol_conf.raw_trace,"Show raw trace event output (do not use print fmt or plugins)" ), +OPT_BOOLEAN (0 ,"hierarchy" , &symbol_conf.report_hierarchy, +"Show entries in a hierarchy" ),OPT_END () }; const char * const top_usage[] = {
@@ -1241,6 +1243,19 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused) goto out_delete_evlist; } +if (symbol_conf.report_hierarchy) { +/* disable incompatible options */ + symbol_conf.event_group = false; + symbol_conf.cumulate_callchain = false; + +if (field_order) { +pr_err ("Error: --hierarchy and --fields options cannot be used together\n" ); +parse_options_usage (top_usage, options,"fields" ,0 ); +parse_options_usage (NULL , options,"hierarchy" ,0 ); + goto out_delete_evlist; + } + } + sort__mode =SORT_MODE__TOP ;/* display thread wants entries to be collapsed in a different tree */ sort__need_collapse =1 ;
Arnaldo Carvalho de Melo
maintainerEm Thu, Feb 25, 2016 at 12:13:32AM +0900, Namhyung Kim escreveu:
Quoted 11 lines
Hello,
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries belong to an upper-level entry. The entry hierachy is built on the sort keys given, so users can set it whatever they want. It only shows top-level entries first, and user can expand/collapse it dynamically.
* Changes from v6)
- pass srcline, srcfile andtrace_outputof hist entry properly (Jiri)
- usehist_entry__snprintf_alignment()(Jiri)
All looks well, doing some more testing now, thanks for the work!
- Arnaldo
Arnaldo Carvalho de Melo
maintainerEm Thu, Feb 25, 2016 at 12:13:32AM +0900, Namhyung Kim escreveu:
Quoted 11 lines
Hello,
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries belong to an upper-level entry. The entry hierachy is built on the sort keys given, so users can set it whatever they want. It only shows top-level entries first, and user can expand/collapse it dynamically.
* Changes from v6)
- pass srcline, srcfile andtrace_outputof hist entry properly (Jiri)
- usehist_entry__snprintf_alignment()(Jiri)
Suggestion for further improvement:
perf top --hierarchy -e sched:sched_switch -s prev_comm,prev_pid,next_comm,next_pid
Will have four levels, would be nice to have just two, perhaps expressed via:
perf top --hierarchy -e sched:sched_switch -s prev_comm+prev_pid,next_comm+next_pid
Where '+' would work as sort order separator, just like ',' but would have special meaning for --hierarchy.
What do you think?
- Arnaldo
Namhyung Kim
maintainerQuoted 20 lines · Arnaldo Carvalho de Melo
Em Thu, Feb 25, 2016 at 12:13:32AM +0900, Namhyung Kim escreveu:
Quoted 11 lines
Hello,
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries belong to an upper-level entry. The entry hierachy is built on the sort keys given, so users can set it whatever they want. It only shows top-level entries first, and user can expand/collapse it dynamically.
* Changes from v6)
- pass srcline, srcfile andtrace_outputof hist entry properly (Jiri)
- usehist_entry__snprintf_alignment()(Jiri)Suggestion for further improvement:
perf top --hierarchy -e sched:sched_switch -s prev_comm,prev_pid,next_comm,next_pid
Will have four levels, would be nice to have just two, perhaps expressed via:
Quoted 6 lines
perf top --hierarchy -e sched:sched_switch -s prev_comm+prev_pid,next_comm+next_pid
Where '+' would work as sort order separator, just like ',' but would have special meaning for --hierarchy.
What do you think?
Looks like a good addition. To do that, a hist entry has to have its own perf_hpp_list instead of a single perf_hpp_fmt. I'll try to implement it..
Thanks,
Namhyung
Arnaldo Carvalho de Melo
maintainerEm Thu, Feb 25, 2016 at 12:13:32AM +0900, Namhyung Kim escreveu:
Quoted 7 lines
Hello,
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries belong to an upper-level entry. The entry hierachy is built on the sort keys given, so users can set it whatever they want. It only shows top-level entries first, and user can expand/collapse it dynamically.
Some oddity: look at the line with 3.92%, it shows just the DSO... Ok, there probably are no symbols above the specified threshold (--percent-limit 1), but it is strange none the less, perhaps we can add something like:
# Overhead Command / Shared Object / Symbol
# .............. ..............................................................................................................................................
#
72.83% cc1
60.88% cc1
1.92% [.] bitmap_set_bit
7.37% libc-2.22.so
2.90% [.] _int_malloc
|
--2.04%--0
_int_malloc 1.13% [.] _int_free
3.92% [kernel.vmlinux]
(no symbols >= 1%)Original output:
[acme@jouet linux]$ perf report --hierarchy --percent-limit 1 | head -30 no symbols found in /usr/bin/gcc, maybe install a debug package?
# To display the perf.data header info, please use --header/--header-only options. #
#
# Total Lost Samples: 0
#
# Samples: 10K of event 'cycles:ppp'
# Event count (approx.): 6703622666
#
# Overhead Command / Shared Object / Symbol
# .............. ..............................................................................................................................................
#
72.83% cc1
60.88% cc1
1.92% [.] bitmap_set_bit
7.37% libc-2.22.so
2.90% [.] _int_malloc
|
--2.04%--0
_int_malloc 1.13% [.] _int_free
3.92% [kernel.vmlinux]
5.96% as
3.19% [kernel.vmlinux]
1.31% as
5.33% conf
2.39% conf
1.52% libc-2.22.so
1.37% [kernel.vmlinux]
4.88% ld [acme@jouet linux]$
Namhyung Kim
maintainerQuoted 25 lines · Arnaldo Carvalho de Melo
Em Thu, Feb 25, 2016 at 12:13:32AM +0900, Namhyung Kim escreveu:
Quoted 7 lines
Hello,
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries belong to an upper-level entry. The entry hierachy is built on the sort keys given, so users can set it whatever they want. It only shows top-level entries first, and user can expand/collapse it dynamically.
Some oddity: look at the line with 3.92%, it shows just the DSO... Ok, there probably are no symbols above the specified threshold (--percent-limit 1), but it is strange none the less, perhaps we can add something like:
# Overhead Command / Shared Object / Symbol
# .............. .............................................................................................................................................. # 72.83% cc1 60.88% cc1 1.92% [.] bitmap_set_bit 7.37% libc-2.22.so 2.90% [.] _int_malloc | --2.04%--0 _int_malloc
Quoted 3 lines
1.13% [.] _int_free
3.92% [kernel.vmlinux]
(no symbols >= 1%)Hmm.. makes sense. But the problem is that these non-entry lines hinder counting the number of (printed) entries which might break the output in some way. Maybe I can use a mock entry to work around it. I'll try to do something. :)
Thanks,
Namhyung
Quoted 38 lines
Original output:
[acme@jouet linux]$ perf report --hierarchy --percent-limit 1 | head -30 no symbols found in
/usr/bin/gcc, maybe install a debug package?
# To display the perf.data header info, please use --header/--header-only options. #
#
# Total Lost Samples: 0
#
# Samples: 10K of event 'cycles:ppp'
# Event count (approx.): 6703622666
#
# Overhead Command / Shared Object / Symbol# .............. .............................................................................................................................................. # 72.83% cc1 60.88% cc1 1.92% [.] bitmap_set_bit 7.37% libc-2.22.so 2.90% [.] _int_malloc | --2.04%--0 _int_malloc1.13% [.] _int_free 3.92% [kernel.vmlinux] 5.96% as 3.19% [kernel.vmlinux] 1.31% as 5.33% conf 2.39% conf 1.52% libc-2.22.so 1.37% [kernel.vmlinux] 4.88% ld[acme@jouet linux]$