perf report/gtk: Add support for hierarchy view
Namhyung Kim
maintainercover perf report/gtk: Add support for hierarchy view
Hi guys,
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries are belonged 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.
This is only implemented in --gtk currently, since it's well-matched to the GTK tree view widget and I didn't want to be bothered with the TUI browser code at this stage. :)
I don't attach a screenshot now, but this is an hypothetical example on stdio. An usual output of perf report look like:
Overhead Command Shared Object Symbol
........ ....... ................. ........................................
22.70% swapper [kernel.kallsyms] [k] intel_idle
8.36% swapper [kernel.kallsyms] [k] irqtime_acouunt_process_tick.isra.74
1.33% swapper [kernel.kallsyms] [k] __scheduleIf --hierarchy (-H) option is given, it'll look like (after expanding all children):
Overhead Command / Shared Object / Symbol
........ ..............................................
32.39% - swapper
32.39% - [kernel.kallsyms]
22.70% [k] intel_idle
8.36% [k] irqtime_acouunt_process_tick.isra.74
1.33% [k] __schedule(The overhead of an upper-level entry is the sum of lower-level entries' overhead).
You can get it from 'perf/hierarchy-v1' branch on my tree at:
git://git.kernel.org/pub/scm/linux/kernel/git/namhyung-perf.git
Any comments are welcome, thanks!
Namhyung
Namhyung Kim (7):
perf hists: Basic support of hierarchical view
perf gtk/hists: Use GtkTreeStore instead of GtkListStore perf gtk/hists: Factor out perf_gtk__add_entries() perf gtk/hists: Add support for hierachical output perf report: Add -H (--hierarchy) option
perf gtk/hists: Add a double-click handler for hierarchy mode perf gtk/hists: Set rules hint for the hist browser
tools/perf/Documentation/perf-report.txt | 5 + tools/perf/builtin-report.c | 6 + tools/perf/ui/gtk/hists.c | 192 ++++++++++++++---- tools/perf/util/hist.c | 325 +++++++++++++++++++++++++++---- tools/perf/util/sort.h | 3 + tools/perf/util/symbol.h | 3 +- 6 files changed, 460 insertions(+), 74 deletions(-)
Signature · 1 line
1.7.11.7
Namhyung Kim
maintainerPATCH 1/7 perf hists: Basic support of hierarchical view
From: Namhyung Kim <[email protected]>
In a hierarchical view, the events sorted and grouped on first key, and then second key, and so on. Now each hist entry has 3 of hroots to save it's children entries.
--- tools/perf/util/hist.c | 325 +++++++++++++++++++++++++++++++++++++++++------ tools/perf/util/sort.h | 3 + tools/perf/util/symbol.h | 3 +- 3 files changed, 291 insertions(+), 40 deletions(-)
tools/perf/util/hist.c +286 -39
@@ -348,7 +348,7 @@ static u8 symbol__parent_filter(const struct symbol *parent)return 0 ; } -static struct hist_entry *add_hist_entry(struct hists *hists, +static struct hist_entry *__add_hist_entry(struct hists *hists, struct hist_entry *entry, struct addr_location *al, u64 period,
@@ -417,6 +417,96 @@ out_unlock:return he; } +static struct hist_entry *__add_hist_entry_hierarchy (struct hists *hists, +struct hist_entry *entry, +struct addr_location *al, +u64 period,u64 weight) +{ +struct rb_root *root; +struct rb_node **p; +struct rb_node *parent =NULL ; +struct hist_entry *he =NULL ; +struct sort_entry *se; +int cmp; + +pthread_mutex_lock (&hists->lock); + + root = hists->entries_in; + p = &root->rb_node; + +list_for_each_entry (se, &hist_entry__sort_list, list) { +while (*p !=NULL ) { + parent = *p; + he = rb_entry(parent, struct hist_entry, rb_node_in); + +/* +* Make sure that it receives arguments in a same order as +* hist_entry__collapse() so that we can use an appropriate +* function when searching an entry regardless which sort +* keys were used. +*/ + cmp = se->se_cmp (he, entry); + +if (!cmp) { +he_stat__add_period (&he->stat, period, weight); + +/* +* This mem info was allocated from machine__resolve_mem +* and will not be used anymore. +*/ +free (entry->mem_info); + +/* If the map of an existing hist_entry has +* become out-of-date due to an exec() or +* similar, update it. Otherwise we will +* mis-adjust symbol addresses when computing +* the history counter to increment. +*/ +if (he->ms.map != entry->ms.map) { + he->ms.map = entry->ms.map; +if (he->ms.map) + he->ms.map->referenced = true; + } + goto next; + } + +if (cmp <0 ) + p = &(*p)->rb_left; +else + p = &(*p)->rb_right; + } + + he =hist_entry__new (entry); +if (!he) + goto out_unlock; + +rb_link_node (&he->rb_node_in, parent, p); +rb_insert_color (&he->rb_node_in, root); +next: +hist_entry__add_cpumode_period (he, al->cpumode, period); + + root = &he->rb_hroot_in; + p = &root->rb_node; + parent =NULL ; + } + +out_unlock: +pthread_mutex_unlock (&hists->lock); +return he; +} + +static struct hist_entry *add_hist_entry (struct hists *hists, +struct hist_entry *entry, +struct addr_location *al, +u64 period, +u64 weight) +{ +if (!symbol_conf.hierarchy) +return __add_hist_entry (hists, entry, al, period, weight); + +return __add_hist_entry_hierarchy (hists, entry, al, period, weight); +} + struct hist_entry *__hists__add_mem_entry(struct hists *self, struct addr_location *al, struct symbol *sym_parent,
@@ -548,6 +638,8 @@ void hist_entry__free(struct hist_entry *he)free (he); } +static void hists__apply_filters (struct hists *hists,struct hist_entry *he); +/* * collapse the histogram */
@@ -591,56 +683,148 @@ static bool hists__collapse_insert_entry(struct hists *hists __maybe_unused,return true; } -static struct rb_root *hists__get_rotate_entries_in (struct hists *hists) +static void hists__collapse_resort_entries (struct hists *hists, +struct rb_root *root_in, +struct rb_root *root) { -struct rb_root *root; - -pthread_mutex_lock (&hists->lock); +struct rb_node *next; +struct hist_entry *he; - root = hists->entries_in; -if (++hists->entries_in > &hists->entries_in_array[1 ]) - hists->entries_in = &hists->entries_in_array[0 ]; + next =rb_first (root_in); -pthread_mutex_unlock (&hists->lock); +while (next) { + he = rb_entry(next, struct hist_entry, rb_node_in); + next =rb_next (&he->rb_node_in); -return root; +rb_erase (&he->rb_node_in, root_in); +if (hists__collapse_insert_entry (hists, root, he)) { +/* +* If it wasn't combined with one of the entries already +* collapsed, we need to apply the filters that may have +* been set by, say, the hist_browser. +*/ +hists__apply_filters (hists, he); + } + } } -static void hists__apply_filters (struct hists *hists,struct hist_entry *he) +static struct hist_entry * +__collapse_insert_entry_hierarchy (struct rb_root *root,struct hist_entry *he, +struct sort_entry *se) { -hists__filter_entry_by_dso (hists, he); -hists__filter_entry_by_thread (hists, he); -hists__filter_entry_by_symbol (hists, he); +struct rb_node **p = &root->rb_node; +struct rb_node *parent =NULL ; +struct hist_entry *iter; +int64_t cmp; + +while (*p !=NULL ) { +int64_t (*f)(struct hist_entry *,struct hist_entry *); + f = se->se_collapse ?: se->se_cmp; + + parent = *p; + iter = rb_entry(parent, struct hist_entry, rb_node_in); + + cmp =f (iter, he); + +if (!cmp) { +he_stat__add_stat (&iter->stat, &he->stat); + +if (symbol_conf.use_callchain) { +callchain_cursor_reset (&callchain_cursor); +callchain_merge (&callchain_cursor, + iter->callchain, + he->callchain); + } +return iter; + } + +if (cmp <0 ) + p = &(*p)->rb_left; +else + p = &(*p)->rb_right; + } + +rb_link_node (&he->rb_node_in, parent, p); +rb_insert_color (&he->rb_node_in, root); +return he; } -static void __hists__collapse_resort (struct hists *hists,bool threaded) +static void +hists__collapse_resort_entries_hierarchy (struct hists *hists, +struct rb_root *root_in, +struct rb_root *root, +struct sort_entry *se) { -struct rb_root *root;struct rb_node *next; -struct hist_entry *n; +struct hist_entry *he; +struct sort_entry *se_next; -if (!sort__need_collapse && !threaded) + next =rb_first (root_in); +if (next ==NULL )return ; - root =hists__get_rotate_entries_in (hists); - next =rb_first (root); +BUG_ON (&se->list == &hist_entry__sort_list); + se_next = list_entry(se->list.next, struct sort_entry, list);while (next) { - n = rb_entry(next, struct hist_entry, rb_node_in); - next =rb_next (&n->rb_node_in); +struct hist_entry *he_new; + + he = rb_entry(next, struct hist_entry, rb_node_in); + next =rb_next (&he->rb_node_in); -rb_erase (&n->rb_node_in, root); -if (hists__collapse_insert_entry (hists, &hists->entries_collapsed, n)) { +rb_erase (&he->rb_node_in, root_in); + he_new =__collapse_insert_entry_hierarchy (root, he, se); +if (he == he_new) {/* * If it wasn't combined with one of the entries already * collapsed, we need to apply the filters that may have * been set by, say, the hist_browser. */ -hists__apply_filters (hists, n); +hists__apply_filters (hists, he); } + +hists__collapse_resort_entries_hierarchy (hists, &he->rb_hroot_in, + &he_new->rb_hroot_collapsed, se_next); + +if (he != he_new) +hist_entry__free (he); } } +static struct rb_root *hists__get_rotate_entries_in (struct hists *hists) +{ +struct rb_root *root; + +pthread_mutex_lock (&hists->lock); + + root = hists->entries_in; +if (++hists->entries_in > &hists->entries_in_array[1 ]) + hists->entries_in = &hists->entries_in_array[0 ]; + +pthread_mutex_unlock (&hists->lock); + +return root; +} + +static void __hists__collapse_resort (struct hists *hists,bool threaded) +{ +struct rb_root *root_in; +struct rb_root *root; +struct sort_entry *se; + +if (!sort__need_collapse && !threaded) +return ; + + root_in =hists__get_rotate_entries_in (hists); + root = &hists->entries_collapsed; + +if (!symbol_conf.hierarchy) +return hists__collapse_resort_entries (hists, root_in, root); + + se = list_first_entry(&hist_entry__sort_list, struct sort_entry, list); +hists__collapse_resort_entries_hierarchy (hists, root_in, root, se); +} +void hists__collapse_resort (struct hists *hists) {return __hists__collapse_resort (hists, false);
@@ -711,11 +895,11 @@ out:return ret; } -static void __hists__insert_output_entry (struct rb_root *entries, +static void __hists__insert_output_entry (struct rb_root *root,struct hist_entry *he,u64 min_callchain_hits) { -struct rb_node **p = &entries->rb_node; +struct rb_node **p = &root->rb_node;struct rb_node *parent =NULL ;struct hist_entry *iter;
@@ -734,37 +918,92 @@ static void __hists__insert_output_entry(struct rb_root *entries, }rb_link_node (&he->rb_node, parent, p); -rb_insert_color (&he->rb_node, entries); +rb_insert_color (&he->rb_node, root); +} + +static void hists__output_resort_entries (struct hists *hists, +struct rb_root *root_in, +struct rb_root *root, +u64 min_callchain_hits) +{ +struct rb_node *next; +struct hist_entry *he; + + next =rb_first (root_in); + +while (next) { + he = rb_entry(next, struct hist_entry, rb_node_in); + next =rb_next (&he->rb_node_in); + +__hists__insert_output_entry (root, he, min_callchain_hits); +hists__inc_nr_entries (hists, he); + } +} + +static void hists__output_resort_entries_hierarchy (struct hists *hists, +struct rb_root *root_in, +struct rb_root *root, +u64 min_callchain_hits, +bool threaded) +{ +struct rb_node *next; +struct hist_entry *he; +struct rb_root *hroot_in; + + next =rb_first (root_in); + +if (next ==NULL ) { + he = list_entry(root, struct hist_entry, rb_hroot); +/* only count leaf nodes */ +hists__inc_nr_entries (hists, he); +return ; + } + +while (next) { + he = rb_entry(next, struct hist_entry, rb_node_in); + next =rb_next (&he->rb_node_in); + +__hists__insert_output_entry (root, he, min_callchain_hits); + +if (sort__need_collapse || threaded) + hroot_in = &he->rb_hroot_collapsed; +else + hroot_in = &he->rb_hroot_in; + +hists__output_resort_entries_hierarchy (hists, hroot_in, + &he->rb_hroot, + min_callchain_hits, + threaded); + } }static void __hists__output_resort (struct hists *hists,bool threaded) { +struct rb_root *root_in;struct rb_root *root; -struct rb_node *next; -struct hist_entry *n;u64 min_callchain_hits; min_callchain_hits = hists->stats.total_period * (callchain_param.min_percent /100 );if (sort__need_collapse || threaded) - root = &hists->entries_collapsed; + root_in = &hists->entries_collapsed;else - root = hists->entries_in; + root_in = hists->entries_in; - next =rb_first (root); hists->entries =RB_ROOT ; + root = &hists->entries; hists->nr_entries =0 ; hists->stats.total_period =0 ;hists__reset_col_len (hists); -while (next) { - n = rb_entry(next, struct hist_entry, rb_node_in); - next =rb_next (&n->rb_node_in); - -__hists__insert_output_entry (&hists->entries, n, min_callchain_hits); -hists__inc_nr_entries (hists, n); +if (!symbol_conf.hierarchy) { +return hists__output_resort_entries (hists, root_in, root, + min_callchain_hits); } + +hists__output_resort_entries_hierarchy (hists, root_in, root, + min_callchain_hits, threaded); }void hists__output_resort (struct hists *hists)
@@ -889,6 +1128,14 @@ void hists__filter_by_symbol(struct hists *hists) } } +static void hists__apply_filters (struct hists *hists,struct hist_entry *he) +{ +hists__filter_entry_by_dso (hists, he); +hists__filter_entry_by_thread (hists, he); +hists__filter_entry_by_symbol (hists, he); +} + +int hist_entry__inc_addr_samples (struct hist_entry *he,int evidx,u64 ip) {return symbol__inc_addr_samples (he->ms.sym, he->ms.map, evidx, ip);
tools/perf/util/sort.h +3 -0
@@ -75,6 +75,9 @@ struct hist_entry_diff {struct hist_entry {struct rb_node rb_node_in;struct rb_node rb_node; +struct rb_root rb_hroot_in; +struct rb_root rb_hroot_collapsed; +struct rb_root rb_hroot;union {struct list_head node;struct list_head head;
tools/perf/util/symbol.h +2 -1
@@ -98,7 +98,8 @@ struct symbol_conf { annotate_asm_raw, annotate_src, event_group, - demangle; + demangle, + hierarchy;const char *vmlinux_name, *kallsyms_name, *source_prefix,
Signature · 1 line
1.7.11.7
Namhyung Kim
maintainerPATCH 2/7 perf gtk/hists: Use GtkTreeStore instead of GtkListStore
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
The GtkTreeStore can save items in a tree-like way. This is a preparation for supporting hierachical output in the hist browser.
--- tools/perf/ui/gtk/hists.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
tools/perf/ui/gtk/hists.c +5 -5
@@ -130,7 +130,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)GType col_types[MAX_COLUMNS ];GtkCellRenderer *renderer;struct sort_entry *se; -GtkListStore *store; +GtkTreeStore *store;struct rb_node *nd;GtkWidget *view;int col_idx;
@@ -155,7 +155,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists) col_types[nr_cols++] =G_TYPE_STRING ; } - store =gtk_list_store_newv (nr_cols, col_types); + store =gtk_tree_store_newv (nr_cols, col_types); view =gtk_tree_view_new ();
@@ -193,7 +193,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)if (h->filtered)continue ; -gtk_list_store_append (store, &iter); +gtk_tree_store_append (store, &iter,NULL ); col_idx =0 ;
@@ -203,7 +203,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)else fmt->entry (&hpp, h); -gtk_list_store_set (store, &iter, col_idx++, s,-1 ); +gtk_tree_store_set (store, &iter, col_idx++, s,-1 ); }list_for_each_entry (se, &hist_entry__sort_list, list) {
@@ -213,7 +213,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists) se->se_snprintf (h, s,ARRAY_SIZE (s),hists__col_len (hists, se->se_width_idx)); -gtk_list_store_set (store, &iter, col_idx++, s,-1 ); +gtk_tree_store_set (store, &iter, col_idx++, s,-1 ); } }
Signature · 1 line
1.7.11.7
Namhyung Kim
maintainerPATCH 3/7 perf gtk/hists: Factor out perf_gtk__add_entries()
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
This is a preparation for supporting hierarchical output in the hist browser.
--- tools/perf/ui/gtk/hists.c | 72 +++++++++++++++++++++++++++-------------------- 1 file changed, 41 insertions(+), 31 deletions(-)
tools/perf/ui/gtk/hists.c +41 -31
@@ -124,6 +124,46 @@ void perf_gtk__init_hpp(void) perf_gtk__hpp_color_overhead_guest_us; } +static void perf_gtk__add_entries (struct hists *hists,struct perf_hpp *hpp, +GtkTreeStore *store) +{ +int col_idx; +struct rb_node *nd; +struct perf_hpp_fmt *fmt; +struct sort_entry *se; + +for (nd =rb_first (&hists->entries); nd; nd =rb_next (nd)) { + struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); +GtkTreeIter iter; + +if (h->filtered) +continue ; + +gtk_tree_store_append (store, &iter,NULL ); + + col_idx =0 ; + +perf_hpp__for_each_format (fmt) { +if (fmt->color) + fmt->color (hpp, h); +else + fmt->entry (hpp, h); + +gtk_tree_store_set (store, &iter, col_idx++, hpp->buf,-1 ); + } + +list_for_each_entry (se, &hist_entry__sort_list, list) { +if (se->elide) +continue ; + + se->se_snprintf (h, hpp->buf, hpp->size, +hists__col_len (hists, se->se_width_idx)); + +gtk_tree_store_set (store, &iter, col_idx++, hpp->buf,-1 ); + } + } +} +static void perf_gtk__show_hists (GtkWidget *window,struct hists *hists) {struct perf_hpp_fmt *fmt;
@@ -131,7 +171,6 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)GtkCellRenderer *renderer;struct sort_entry *se;GtkTreeStore *store; -struct rb_node *nd;GtkWidget *view;int col_idx;int nr_cols;
@@ -186,36 +225,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)g_object_unref (GTK_TREE_MODEL (store)); -for (nd =rb_first (&hists->entries); nd; nd =rb_next (nd)) { - struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); -GtkTreeIter iter; - -if (h->filtered) -continue ; - -gtk_tree_store_append (store, &iter,NULL ); - - col_idx =0 ; - -perf_hpp__for_each_format (fmt) { -if (fmt->color) - fmt->color (&hpp, h); -else - fmt->entry (&hpp, h); - -gtk_tree_store_set (store, &iter, col_idx++, s,-1 ); - } - -list_for_each_entry (se, &hist_entry__sort_list, list) { -if (se->elide) -continue ; - - se->se_snprintf (h, s,ARRAY_SIZE (s), -hists__col_len (hists, se->se_width_idx)); - -gtk_tree_store_set (store, &iter, col_idx++, s,-1 ); - } - } +perf_gtk__add_entries (hists, &hpp, store);gtk_container_add (GTK_CONTAINER (window), view); }
Signature · 1 line
1.7.11.7
Namhyung Kim
maintainerPATCH 4/7 perf gtk/hists: Add support for hierachical output
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
When the symbol_conf.hierarchy is set, perf will collapse entries by a first sort key, and then second key, and so on in a hierarchical manner. It'll be looked like a tree view so set the expander column to a column that displays sort entries.
--- tools/perf/ui/gtk/hists.c | 109 +++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 103 insertions(+), 6 deletions(-)
tools/perf/ui/gtk/hists.c +103 -6
@@ -164,6 +164,62 @@ static void perf_gtk__add_entries(struct hists *hists, struct perf_hpp *hpp, } } +static void __perf_gtk__add_entries_hierarchy (struct hists *hists, +struct rb_root *root, +GtkTreeStore *store, +GtkTreeIter *parent, +struct perf_hpp *hpp, +struct sort_entry *se) +{ +int col_idx; +struct rb_node *nd; +struct perf_hpp_fmt *fmt; + +for (nd =rb_first (root); nd; nd =rb_next (nd)) { + struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node); +GtkTreeIter iter; +struct sort_entry *next_se; + +if (h->filtered) +continue ; + +gtk_tree_store_append (store, &iter, parent); + + col_idx =0 ; + +perf_hpp__for_each_format (fmt) { +if (fmt->color) + fmt->color (hpp, h); +else + fmt->entry (hpp, h); + +gtk_tree_store_set (store, &iter, col_idx++, hpp->buf,-1 ); + } + + se->se_snprintf (h, hpp->buf, hpp->size, +hists__col_len (hists, se->se_width_idx)); + +gtk_tree_store_set (store, &iter, col_idx++,ltrim (hpp->buf),-1 ); + + next_se = list_entry(se->list.next, struct sort_entry, list); +__perf_gtk__add_entries_hierarchy (hists, &h->rb_hroot, store, + &iter, hpp, next_se); + } +} + +static void perf_gtk__add_entries_hierarchy (struct hists *hists, +struct perf_hpp *hpp, +GtkTreeStore *store) +{ +struct rb_root *root; +struct sort_entry *se; + + root = &hists->entries; + se = list_first_entry(&hist_entry__sort_list, struct sort_entry, list); + +__perf_gtk__add_entries_hierarchy (hists, root, store,NULL , hpp, se); +} +static void perf_gtk__show_hists (GtkWidget *window,struct hists *hists) {struct perf_hpp_fmt *fmt;
@@ -173,6 +229,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)GtkTreeStore *store;GtkWidget *view;int col_idx; +int sort_col =0 ;int nr_cols;char s[512 ];
@@ -187,11 +244,19 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)perf_hpp__for_each_format (fmt) col_types[nr_cols++] =G_TYPE_STRING ; -list_for_each_entry (se, &hist_entry__sort_list, list) { -if (se->elide) -continue ; - - col_types[nr_cols++] =G_TYPE_STRING ; +if (symbol_conf.hierarchy) { +/* +* In --hierarchy mode, all sort entries are displayed in a +* single column. +*/ + col_types[nr_cols] =G_TYPE_STRING ; + sort_col = nr_cols++; + }else { +list_for_each_entry (se, &hist_entry__sort_list, list) { +if (se->elide) +continue ; + col_types[nr_cols++] =G_TYPE_STRING ; + } } store =gtk_tree_store_newv (nr_cols, col_types);
@@ -211,6 +276,26 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists) col_idx++, NULL); } +if (symbol_conf.hierarchy) { +bool first = true; + + s[0 ] ='\0' ; +list_for_each_entry (se, &hist_entry__sort_list, list) { +if (!first) +strcat (s," / " ); + +strcat (s, se->se_header); + + first = false; + } + +gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), +-1 , s, + renderer,"text" , + col_idx++,NULL ); + goto add; + } +list_for_each_entry (se, &hist_entry__sort_list, list) {if (se->elide)continue ;
@@ -221,11 +306,23 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists) col_idx++, NULL); } +add:gtk_tree_view_set_model (GTK_TREE_VIEW (view),GTK_TREE_MODEL (store));g_object_unref (GTK_TREE_MODEL (store)); -perf_gtk__add_entries (hists, &hpp, store); +if (!symbol_conf.hierarchy) +perf_gtk__add_entries (hists, &hpp, store); +else { +GtkTreeViewColumn *expander_col; + + expander_col =gtk_tree_view_get_column (GTK_TREE_VIEW (view), + sort_col); +gtk_tree_view_set_expander_column (GTK_TREE_VIEW (view), + expander_col); + +perf_gtk__add_entries_hierarchy (hists, &hpp, store); + }gtk_container_add (GTK_CONTAINER (window), view); }
Signature · 1 line
1.7.11.7
Namhyung Kim
maintainerPATCH 5/7 perf report: Add -H (--hierarchy) option
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
It's for enabling the hierarchical view.
--- tools/perf/Documentation/perf-report.txt | 5 +++++ tools/perf/builtin-report.c | 6 ++++++ 2 files changed, 11 insertions(+)
tools/perf/Documentation/perf-report.txt +5 -0
@@ -210,6 +210,11 @@ OPTIONS Demangle symbol names to human readable form. It's enabled by default, disable with --no-demangle. +-H:: +--hierarchy:: + Show events in hierarchical view. Each events are grouped under prior + sort keys. Currently --gtk output is supported only. + SEE ALSO -------- linkperf:perf-stat[1], linkperf:perf-annotate[1]
tools/perf/builtin-report.c +6 -0
@@ -809,6 +809,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)OPT_BOOLEAN (0 ,"demangle" , &symbol_conf.demangle,"Disable symbol demangling" ),OPT_BOOLEAN (0 ,"mem-mode" , &report.mem_mode,"mem access profile" ), +OPT_BOOLEAN ('H' ,"hierarchy" , &symbol_conf.hierarchy,"Hierarchical view" ), OPT_END() };
@@ -833,6 +834,11 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused) input_name ="perf.data" ; } +if (symbol_conf.hierarchy && use_browser !=2 ) { +pr_err ("--hierarchy option is only used for --gtk output\n" ); +return -EINVAL ; + } +if (strcmp (input_name,"-" ) !=0 )setup_browser (true);else {
Signature · 1 line
1.7.11.7
Namhyung Kim
maintainerPATCH 6/7 perf gtk/hists: Add a double-click handler for hierarchy mode
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
If hierarchy mode is enabled, add "row-activated" signal handler for handling double-click or pressing ENTER key action.
--- tools/perf/ui/gtk/hists.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
tools/perf/ui/gtk/hists.c +15 -0
@@ -220,6 +220,18 @@ static void perf_gtk__add_entries_hierarchy(struct hists *hists,__perf_gtk__add_entries_hierarchy (hists, root, store,NULL , hpp, se); } +static void on_row_activated (GtkTreeView *view,GtkTreePath *path, +GtkTreeViewColumn *col__maybe_unused , +gpointer user_data__maybe_unused ) +{ +bool expanded =gtk_tree_view_row_expanded (view, path); + +if (expanded) +gtk_tree_view_collapse_row (view, path); +else +gtk_tree_view_expand_row (view, path, FALSE); +} +static void perf_gtk__show_hists (GtkWidget *window,struct hists *hists) {struct perf_hpp_fmt *fmt;
@@ -322,6 +334,9 @@ add: expander_col);perf_gtk__add_entries_hierarchy (hists, &hpp, store); + +g_signal_connect (view,"row-activated" , +G_CALLBACK (on_row_activated),NULL ); }gtk_container_add (GTK_CONTAINER (window), view);
Signature · 1 line
1.7.11.7
Namhyung Kim
maintainerPATCH 7/7 perf gtk/hists: Set rules hint for the hist browser
In reply to Namhyung KimFrom: Namhyung Kim <[email protected]>
The 'rules' means that every second line of the tree view has a shaded background, which makes it easier to see which cell belongs to which row in the tree view. It can be useful for a tree view that has a lot of rows.
--- tools/perf/ui/gtk/hists.c | 2 ++ 1 file changed, 2 insertions(+)
tools/perf/ui/gtk/hists.c +2 -0
@@ -339,6 +339,8 @@ add: G_CALLBACK(on_row_activated), NULL); } +gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); +gtk_container_add (GTK_CONTAINER (window), view); }
Signature · 1 line
1.7.11.7
Hello,
Quoted 9 lines · Namhyung Kim
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries are belonged 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.
This is only implemented in --gtk currently, since it's well-matched to the GTK tree view widget and I didn't want to be bothered with the TUI browser code at this stage. :)
Can use this infrastructure to support call-graphs in the GTK UI?
Pekka
Namhyung Kim
maintainerHi Pekka,
Quoted 9 lines · Pekka Enberg
Hello,
Quoted 6 lines · Namhyung Kim
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries are belonged 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.
Quoted 5 lines
Quoted 3 lines
This is only implemented in --gtk currently, since it's well-matched to the GTK tree view widget and I didn't want to be bothered with the TUI browser code at this stage. :)
Can use this infrastructure to support call-graphs in the GTK UI?
Yes, I think it's doable. I don't have an idea how to use both of the features at the same time though. Anyway, I'll try to add support for callchains later.
Thanks,
Namhyung
Quoted 14 lines · Namhyung Kim
Quoted 13 lines · Pekka Enberg
Hello,
Quoted 9 lines · Namhyung Kim
This patchset implements a new feature that collects hist entries in a hierachical manner. That means lower-level entries are belonged 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.
This is only implemented in --gtk currently, since it's well-matched to the GTK tree view widget and I didn't want to be bothered with the TUI browser code at this stage. :)
Quoted 5 lines
Quoted 1 line
Can use this infrastructure to support call-graphs in the GTK UI?
Yes, I think it's doable. I don't have an idea how to use both of the features at the same time though. Anyway, I'll try to add support for callchains later.
So I think hierarchy view makes tons of sense but it needs to be orthogonal with call-graphs. Preferably in such a way that if you have both hierarchy view and call-graphs enabled, you can seamlessly drill down from process level all the way to call-graph leaf nodes.
Pekka