1 files changed, 260 insertions, 42 deletions

diff --git a/tools/perf/ui/stdio/hist.c b/tools/perf/ui/stdio/hist.c
index 387110d50b00..7aff5acf3265 100644
--- a/tools/perf/ui/stdio/hist.c
+++ b/tools/perf/ui/stdio/hist.c
@@ -165,8 +165,28 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct rb_root *root,
         return ret;
 }
 
+/*
+ * If have one single callchain root, don't bother printing
+ * its percentage (100 % in fractal mode and the same percentage
+ * than the hist in graph mode). This also avoid one level of column.
+ *
+ * However when percent-limit applied, it's possible that single callchain
+ * node have different (non-100% in fractal mode) percentage.
+ */
+static bool need_percent_display(struct rb_node *node, u64 parent_samples)
+{
+        struct callchain_node *cnode;
+
+        if (rb_next(node))
+                return true;
+
+        cnode = rb_entry(node, struct callchain_node, rb_node);
+        return callchain_cumul_hits(cnode) != parent_samples;
+}
+
 static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
-                                       u64 total_samples, int left_margin)
+                                       u64 total_samples, u64 parent_samples,
+                                       int left_margin)
 {
         struct callchain_node *cnode;
         struct callchain_list *chain;
@@ -177,13 +197,8 @@ static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
         int ret = 0;
         char bf[1024];
 
-        /*
-         * If have one single callchain root, don't bother printing
-         * its percentage (100 % in fractal mode and the same percentage
-         * than the hist in graph mode). This also avoid one level of column.
-         */
         node = rb_first(root);
-        if (node && !rb_next(node)) {
+        if (node && !need_percent_display(node, parent_samples)) {
                 cnode = rb_entry(node, struct callchain_node, rb_node);
                 list_for_each_entry(chain, &cnode->val, list) {
                         /*
@@ -213,9 +228,15 @@ static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
                 root = &cnode->rb_root;
         }
 
+        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                total_samples = parent_samples;
+
         ret += __callchain__fprintf_graph(fp, root, total_samples,
                                           1, 1, left_margin);
-        ret += fprintf(fp, "\n");
+        if (ret) {
+                /* do not add a blank line if it printed nothing */
+                ret += fprintf(fp, "\n");
+        }
 
         return ret;
 }
@@ -323,16 +344,19 @@ static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
                                             u64 total_samples, int left_margin,
                                             FILE *fp)
 {
+        u64 parent_samples = he->stat.period;
+
+        if (symbol_conf.cumulate_callchain)
+                parent_samples = he->stat_acc->period;
+
         switch (callchain_param.mode) {
         case CHAIN_GRAPH_REL:
-                return callchain__fprintf_graph(fp, &he->sorted_chain,
-                                                symbol_conf.cumulate_callchain ?
-                                                he->stat_acc->period : he->stat.period,
-                                                left_margin);
+                return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
+                                                parent_samples, left_margin);
                 break;
         case CHAIN_GRAPH_ABS:
                 return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
-                                                left_margin);
+                                                parent_samples, left_margin);
                 break;
         case CHAIN_FLAT:
                 return callchain__fprintf_flat(fp, &he->sorted_chain, total_samples);
@@ -349,45 +373,66 @@ static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
         return 0;
 }
 
-static size_t hist_entry__callchain_fprintf(struct hist_entry *he,
-                                            struct hists *hists,
-                                            FILE *fp)
+static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
 {
-        int left_margin = 0;
-        u64 total_period = hists->stats.total_period;
+        const char *sep = symbol_conf.field_sep;
+        struct perf_hpp_fmt *fmt;
+        char *start = hpp->buf;
+        int ret;
+        bool first = true;
 
-        if (field_order == NULL && (sort_order == NULL ||
-                                    !prefixcmp(sort_order, "comm"))) {
-                struct perf_hpp_fmt *fmt;
+        if (symbol_conf.exclude_other && !he->parent)
+                return 0;
 
-                perf_hpp__for_each_format(fmt) {
-                        if (!perf_hpp__is_sort_entry(fmt))
-                                continue;
+        hists__for_each_format(he->hists, fmt) {
+                if (perf_hpp__should_skip(fmt, he->hists))
+                        continue;
 
-                        /* must be 'comm' sort entry */
-                        left_margin = fmt->width(fmt, NULL, hists_to_evsel(hists));
-                        left_margin -= thread__comm_len(he->thread);
-                        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);
         }
-        return hist_entry_callchain__fprintf(he, total_period, left_margin, fp);
+
+        return hpp->buf - start;
 }
 
-static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
+static int hist_entry__hierarchy_fprintf(struct hist_entry *he,
+                                         struct perf_hpp *hpp,
+                                         struct hists *hists,
+                                         FILE *fp)
 {
         const char *sep = symbol_conf.field_sep;
         struct perf_hpp_fmt *fmt;
-        char *start = hpp->buf;
-        int ret;
+        struct perf_hpp_list_node *fmt_node;
+        char *buf = hpp->buf;
+        size_t size = hpp->size;
+        int ret, printed = 0;
         bool first = true;
 
         if (symbol_conf.exclude_other && !he->parent)
                 return 0;
 
-        perf_hpp__for_each_format(fmt) {
-                if (perf_hpp__should_skip(fmt, he->hists))
-                        continue;
+        ret = scnprintf(hpp->buf, hpp->size, "%*s", he->depth * HIERARCHY_INDENT, "");
+        advance_hpp(hpp, ret);
 
+        /* the first hpp_list_node is for overhead columns */
+        fmt_node = list_first_entry(&hists->hpp_formats,
+                                    struct perf_hpp_list_node, list);
+        perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
                 /*
                  * If there's no field_sep, we still need
                  * to display initial '  '.
@@ -403,10 +448,47 @@ static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
                 else
                         ret = fmt->entry(fmt, hpp, he);
 
+                ret = hist_entry__snprintf_alignment(he, hpp, fmt, ret);
                 advance_hpp(hpp, ret);
         }
 
-        return hpp->buf - start;
+        if (!sep)
+                ret = scnprintf(hpp->buf, hpp->size, "%*s",
+                                (hists->nr_hpp_node - 2) * HIERARCHY_INDENT, "");
+        advance_hpp(hpp, ret);
+
+        printed += fprintf(fp, "%s", buf);
+
+        perf_hpp_list__for_each_format(he->hpp_list, fmt) {
+                hpp->buf  = buf;
+                hpp->size = size;
+
+                /*
+                 * No need to call hist_entry__snprintf_alignment() since this
+                 * fmt is always the last column in the hierarchy mode.
+                 */
+                if (perf_hpp__use_color() && fmt->color)
+                        fmt->color(fmt, hpp, he);
+                else
+                        fmt->entry(fmt, hpp, he);
+
+                /*
+                 * dynamic entries are right-aligned but we want left-aligned
+                 * in the hierarchy mode
+                 */
+                printed += fprintf(fp, "%s%s", sep ?: "  ", ltrim(buf));
+        }
+        printed += putc('\n', fp);
+
+        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,
@@ -418,24 +500,134 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,
                 .buf            = bf,
                 .size           = size,
         };
+        u64 total_period = hists->stats.total_period;
 
         if (size == 0 || size > bfsz)
                 size = hpp.size = bfsz;
 
+        if (symbol_conf.report_hierarchy)
+                return hist_entry__hierarchy_fprintf(he, &hpp, hists, fp);
+
         hist_entry__snprintf(he, &hpp);
 
         ret = fprintf(fp, "%s\n", bf);
 
         if (symbol_conf.use_callchain)
-                ret += hist_entry__callchain_fprintf(he, hists, fp);
+                ret += hist_entry_callchain__fprintf(he, total_period, 0, fp);
 
         return ret;
 }
 
+static int print_hierarchy_indent(const char *sep, int indent,
+                                  const char *line, FILE *fp)
+{
+        if (sep != NULL || indent < 2)
+                return 0;
+
+        return fprintf(fp, "%-.*s", (indent - 2) * HIERARCHY_INDENT, line);
+}
+
+static int print_hierarchy_header(struct hists *hists, struct perf_hpp *hpp,
+                                  const char *sep, FILE *fp)
+{
+        bool first_node, first_col;
+        int indent;
+        int depth;
+        unsigned width = 0;
+        unsigned header_width = 0;
+        struct perf_hpp_fmt *fmt;
+        struct perf_hpp_list_node *fmt_node;
+
+        indent = hists->nr_hpp_node;
+
+        /* preserve max indent depth for column headers */
+        print_hierarchy_indent(sep, indent, spaces, fp);
+
+        /* the first hpp_list_node is for overhead columns */
+        fmt_node = list_first_entry(&hists->hpp_formats,
+                                    struct perf_hpp_list_node, list);
+
+        perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
+                fmt->header(fmt, hpp, hists_to_evsel(hists));
+                fprintf(fp, "%s%s", hpp->buf, sep ?: "  ");
+        }
+
+        /* combine sort headers with ' / ' */
+        first_node = true;
+        list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
+                if (!first_node)
+                        header_width += fprintf(fp, " / ");
+                first_node = false;
+
+                first_col = true;
+                perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
+                        if (perf_hpp__should_skip(fmt, hists))
+                                continue;
+
+                        if (!first_col)
+                                header_width += fprintf(fp, "+");
+                        first_col = false;
+
+                        fmt->header(fmt, hpp, hists_to_evsel(hists));
+                        rtrim(hpp->buf);
+
+                        header_width += fprintf(fp, "%s", ltrim(hpp->buf));
+                }
+        }
+
+        fprintf(fp, "\n# ");
+
+        /* preserve max indent depth for initial dots */
+        print_hierarchy_indent(sep, indent, dots, fp);
+
+        /* the first hpp_list_node is for overhead columns */
+        fmt_node = list_first_entry(&hists->hpp_formats,
+                                    struct perf_hpp_list_node, list);
+
+        first_col = true;
+        perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
+                if (!first_col)
+                        fprintf(fp, "%s", sep ?: "..");
+                first_col = false;
+
+                width = fmt->width(fmt, hpp, hists_to_evsel(hists));
+                fprintf(fp, "%.*s", width, dots);
+        }
+
+        depth = 0;
+        list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
+                first_col = true;
+                width = depth * HIERARCHY_INDENT;
+
+                perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
+                        if (perf_hpp__should_skip(fmt, hists))
+                                continue;
+
+                        if (!first_col)
+                                width++;  /* for '+' sign between column header */
+                        first_col = false;
+
+                        width += fmt->width(fmt, hpp, hists_to_evsel(hists));
+                }
+
+                if (width > header_width)
+                        header_width = width;
+
+                depth++;
+        }
+
+        fprintf(fp, "%s%-.*s", sep ?: "  ", header_width, dots);
+
+        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)
 {
         struct perf_hpp_fmt *fmt;
+        struct perf_hpp_list_node *fmt_node;
         struct rb_node *nd;
         size_t ret = 0;
         unsigned int width;
@@ -449,10 +641,11 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
         bool first = true;
         size_t linesz;
         char *line = NULL;
+        unsigned indent;
 
         init_rem_hits();
 
-        perf_hpp__for_each_format(fmt)
+        hists__for_each_format(hists, fmt)
                 perf_hpp__reset_width(fmt, hists);
 
         if (symbol_conf.col_width_list_str)
@@ -463,7 +656,16 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
 
         fprintf(fp, "# ");
 
-        perf_hpp__for_each_format(fmt) {
+        if (symbol_conf.report_hierarchy) {
+                list_for_each_entry(fmt_node, &hists->hpp_formats, list) {
+                        perf_hpp_list__for_each_format(&fmt_node->hpp, fmt)
+                                perf_hpp__reset_width(fmt, hists);
+                }
+                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;
 
@@ -487,7 +689,7 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
 
         fprintf(fp, "# ");
 
-        perf_hpp__for_each_format(fmt) {
+        hists__for_each_format(hists, fmt) {
                 unsigned int i;
 
                 if (perf_hpp__should_skip(fmt, hists))
@@ -520,7 +722,9 @@ print_entries:
                 goto out;
         }
 
-        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
+        indent = hists__overhead_width(hists) + 4;
+
+        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;
 
@@ -536,6 +740,20 @@ print_entries:
                 if (max_rows && ++nr_rows >= max_rows)
                         break;
 
+                /*
+                 * If all children are filtered out or percent-limited,
+                 * display "no entry >= x.xx%" message.
+                 */
+                if (!h->leaf && !hist_entry__has_hierarchy_children(h, min_pcnt)) {
+                        int depth = hists->nr_hpp_node + h->depth + 1;
+
+                        print_hierarchy_indent(sep, depth, spaces, fp);
+                        fprintf(fp, "%*sno entry >= %.2f%%\n", indent, "", min_pcnt);
+
+                        if (max_rows && ++nr_rows >= max_rows)
+                                break;
+                }
+
                 if (h->ms.map == NULL && verbose > 1) {
                         __map_groups__fprintf_maps(h->thread->mg,
                                                    MAP__FUNCTION, fp);