[PATCH v5 v5 8/9] perf c2c: add function view browser UI and cacheline detail

[Jiebin Sun]

Add the browser front end: create/run/delete the hist_browser and add the
title. The d shortcut opens the existing per-cacheline detail view for the
selected level-3 cacheline. Level-3 entries retain the source cacheline
index, so the shortcut can locate the original entry without relying on a
potentially ambiguous virtual address.

Require `iaddr` in the cacheline coalescing fields before building the
view. Without it, the detail histograms may already have merged samples
from different functions and cannot support reliable function attribution.

Keep visible-row accounting local to the function view by wrapping the
generic browser refresh callback and recounting the currently reachable
hierarchy before each redraw. This keeps navigation correct when a level-1
row is collapsed while level-3 descendants remain expanded, without adding
C2C-specific hooks to the shared hist_browser or enabling report_hierarchy
and its incompatible ownership rules. Also handle Ctrl-C like the other
function-view exit keys.

Wire the builder into perf_c2c__browse_function_view() and refuse to run
under report_hierarchy, whose hist_entry__delete() recursion would put the
borrowed child references.

Signed-off-by: Jiebin Sun <jiebin.sun@xxxxxxxxx>
Cc: Adrian Hunter <adrian.hunter@xxxxxxxxx>
Cc: Alexander Shishkin <alexander.shishkin@xxxxxxxxxxxxxxx>
Cc: Arnaldo Carvalho de Melo <acme@xxxxxxxxxx>
Cc: Dapeng Mi <dapeng1.mi@xxxxxxxxxxxxxxx>
Cc: Ian Rogers <irogers@xxxxxxxxxx>
Cc: Ingo Molnar <mingo@xxxxxxxxxx>
Cc: James Clark <james.clark@xxxxxxxxxx>
Cc: Jiri Olsa <jolsa@xxxxxxxxxx>
Cc: Mark Rutland <mark.rutland@xxxxxxx>
Cc: Namhyung Kim <namhyung@xxxxxxxxxx>
Cc: Peter Zijlstra <peterz@xxxxxxxxxxxxx>
Cc: Thomas Falcon <thomas.falcon@xxxxxxxxx>
Reviewed-by: Tianyou Li <tianyou.li@xxxxxxxxx>
Reviewed-by: Wangyang Guo <wangyang.guo@xxxxxxxxx>
---
 tools/perf/ui/browsers/c2c-function.c | 239 +++++++++++++++++++++++++-
 1 file changed, 236 insertions(+), 3 deletions(-)

diff --git a/tools/perf/ui/browsers/c2c-function.c b/tools/perf/ui/browsers/c2c-function.c
index 9a95355eedf5..44fb072fa937 100644
--- a/tools/perf/ui/browsers/c2c-function.c
+++ b/tools/perf/ui/browsers/c2c-function.c
@@ -15,6 +15,7 @@
 #include <inttypes.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/ttydefaults.h>
 #include <tools/libc_compat.h> /* reallocarray */
 #include <asm/bug.h>
 #include <linux/list.h>
@@ -49,6 +50,7 @@ static struct perf_c2c_ext c2c_ext;
 
 struct c2c_function_browser {
 	struct hist_browser	hb;
+	unsigned int		(*orig_refresh)(struct ui_browser *browser);
 };
 
 static inline u64 c2c_hitm_count(const struct c2c_stats *stats)
@@ -93,6 +95,10 @@ static inline u64 hist_entry__iaddr(struct hist_entry *he)
 	return he->ip;
 }
 
+/*
+ * Hierarchy levels (by depth): L1 = read-side function, L2 = the writing
+ * function it contends with, L3 = the specific shared cacheline.
+ */
 static inline bool hist_entry__is_cacheline(struct hist_entry *he)
 {
 	return he->parent_he && he->parent_he->parent_he;	/* level 3: cacheline */
@@ -701,6 +707,7 @@ c2c_function_hists__reinit(struct c2c_hists *c2c_hists,
 	return function_hpp_list__parse(&c2c_hists->list, output, sort, env);
 }
 
+/* Welford online merge of two "stats" (from util/stat.h) accumulators. */
 static void c2c_stats_merge(struct stats *dest, const struct stats *src)
 {
 	double delta;
@@ -1440,6 +1447,58 @@ static void c2c_function__update_symbol_width(struct hist_entry *he)
 		hists__set_col_len(hists, HISTC_SYMBOL, need);
 }
 
+/*
+ * Count visible entries in @root, descending only through visible, unfolded
+ * parents. Match hists__filter_entries(), which drives generic browser
+ * navigation, so the count cannot include rows the browser skips.
+ */
+static u64
+c2c_function__nr_visible_rows(struct rb_root_cached *root, float min_pcnt)
+{
+	struct rb_node *nd;
+	u64 rows = 0;
+
+	for (nd = rb_first_cached(root); nd; nd = rb_next(nd)) {
+		struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
+
+		/*
+		 * The generic refresh folds filtered parents and therefore hides
+		 * their subtree. A percentage-rejected parent is merely skipped;
+		 * if it is unfolded, qualifying descendants are still rendered.
+		 */
+		if (he->filtered)
+			continue;
+
+		if (hist_entry__get_percent_limit(he) >= min_pcnt)
+			rows++;
+		if (he->has_children && he->unfolded)
+			rows += c2c_function__nr_visible_rows(&he->hroot_out,
+							     min_pcnt);
+	}
+	return rows;
+}
+
+static void
+c2c_function_browser__update_nr_entries(struct c2c_function_browser *browser)
+{
+	u64 nr_entries;
+
+	nr_entries = c2c_function__nr_visible_rows(&browser->hb.hists->entries,
+						   browser->hb.min_pcnt);
+	browser->hb.nr_non_filtered_entries = nr_entries;
+	browser->hb.b.nr_entries = nr_entries;
+}
+
+static unsigned int c2c_function_browser__refresh(struct ui_browser *ui_browser)
+{
+	struct hist_browser *hist_browser = container_of(ui_browser, struct hist_browser, b);
+	struct c2c_function_browser *browser;
+
+	browser = container_of(hist_browser, struct c2c_function_browser, hb);
+	c2c_function_browser__update_nr_entries(browser);
+	return browser->orig_refresh(ui_browser);
+}
+
 /*
  * Prune writers with no stores, drop functions left with no contending
  * writer, sort the survivors by store count, then compute the global total.
@@ -1512,7 +1571,7 @@ static void c2c_function_hists__reset(void)
  *   L2: writing functions contending with each level-1 function
  *   L3: shared cachelines for each function pair
  */
-static int __maybe_unused build_function_view_hierarchy(void)
+static int build_function_view_hierarchy(void)
 {
 	static const char output_fields[] =
 		"cycles_percent,total_stores,symbol_view";
@@ -1591,8 +1650,182 @@ static int __maybe_unused build_function_view_hierarchy(void)
 	return ret;
 }
 
-int perf_c2c__browse_function_view(void)
+static int c2c_function_browser__title(struct hist_browser *browser,
+				       char *bf, size_t size)
 {
-	ui__warning("C2C function view is not implemented yet.\n");
+	scnprintf(bf, size,
+		  "Shared Data Functions Table     (%" PRIu64 " entries, sorted on Cycles %%)",
+		  browser->hists->nr_non_filtered_entries);
 	return 0;
 }
+
+static struct c2c_function_browser *c2c_function_browser__new(struct hists *hists)
+{
+	struct c2c_function_browser *browser;
+
+	if (!hists)
+		return NULL;
+
+	browser = zalloc(sizeof(*browser));
+	if (!browser)
+		return NULL;
+
+	hist_browser__init(&browser->hb, hists);
+	browser->orig_refresh = browser->hb.b.refresh;
+	browser->hb.b.refresh = c2c_function_browser__refresh;
+
+	browser->hb.title = c2c_function_browser__title;
+	browser->hb.c2c_filter = true;
+	browser->hb.show_headers = true;
+	/* Keep title line count consistent with forcing headers on. */
+	browser->hb.b.extra_title_lines = hists->hpp_list->nr_header_lines;
+	browser->hb.min_pcnt = 0.0;
+
+	/*
+	 * Note: symbol_conf.report_hierarchy is deliberately left unset.
+	 * The generic browser still descends into hroot_out children via
+	 * rb_hierarchy_next()/can_goto_child(), which key off he->unfolded,
+	 * so 'e'/'+' expands L1 -> L2 -> L3 correctly. Setting the flag would
+	 * additionally make hist_entry__delete() recurse hroot_out and free
+	 * each child, but our children borrow thread/ms (see
+	 * c2c_child_entry__alloc()), so that would underflow their refcounts.
+	 * Teardown is handled by c2c_he__free_hierarchy() instead.
+	 */
+	return browser;
+}
+
+/*
+ * c2c_function_browser__delete - Free function browser
+ */
+static void c2c_function_browser__delete(struct c2c_function_browser *browser)
+{
+	free(browser);
+}
+
+static int c2c_function_browser__browse_cacheline_detail(struct hist_entry *he_selection)
+{
+	struct c2c_hist_entry *c2c_he;
+	struct rb_node *nd;
+
+	if (!he_selection || !he_selection->parent_he ||
+	    !he_selection->parent_he->parent_he)
+		return -1;
+
+	c2c_he = container_of(he_selection, struct c2c_hist_entry, he);
+
+	for (nd = rb_first_cached(&c2c.hists.hists.entries); nd; nd = rb_next(nd)) {
+		struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
+		struct c2c_hist_entry *cacheline_he;
+
+		if (he->filtered)
+			continue;
+
+		cacheline_he = container_of(he, struct c2c_hist_entry, he);
+		if (cacheline_he->hists &&
+		    cacheline_he->cacheline_idx == c2c_he->cacheline_idx)
+			return perf_c2c__browse_cacheline(he);
+	}
+
+	return -1;
+}
+
+static bool c2c_function__has_iaddr(void)
+{
+	const char *field = c2c.cl_sort;
+
+	while (field && *field) {
+		const char *end = strchr(field, ',');
+		size_t len = end ? (size_t)(end - field) : strlen(field);
+
+		if (len == sizeof("iaddr") - 1 && !strncmp(field, "iaddr", len))
+			return true;
+		field = end ? end + 1 : NULL;
+	}
+	return false;
+}
+
+/*
+ * perf_c2c__browse_function_view - Browse function view with TAB key support
+ *
+ * Returns: 0 on success, negative error code on failure
+ */
+int perf_c2c__browse_function_view(void)
+{
+	struct c2c_function_browser *sym_browser;
+	bool saved_use_callchain = symbol_conf.use_callchain;
+	int key, ret;
+	static const char help[] =
+	" d             Display details for the selected level-3 cacheline\n"
+	" e/+           Expand/collapse the selected entry\n"
+	" TAB/ESC/q/^C  Return to the cacheline view\n";
+
+	if (!c2c_function__has_iaddr()) {
+		ui__warning("The function view requires iaddr in --coalesce.\n");
+		return -EINVAL;
+	}
+
+	/*
+	 * The level-2/3 children borrow thread/ms (see c2c_child_entry__alloc())
+	 * and are torn down by c2c_he__free_hierarchy(). report_hierarchy would
+	 * make hist_entry__delete() recurse into hroot_out and put those borrowed
+	 * refs (and call a NULL ops->free), so refuse to run if it is ever set.
+	 */
+	if (WARN_ON_ONCE(symbol_conf.report_hierarchy))
+		return -EINVAL;
+
+	/* Disable callchain before building so no callchain structs are allocated. */
+	symbol_conf.use_callchain = false;
+
+	ret = build_function_view_hierarchy();
+	if (ret) {
+		ui__error("Failed to build function view hierarchy (ret=%d)\n", ret);
+		goto out;
+	}
+
+	sym_browser = c2c_function_browser__new(&c2c_ext.function_hists.hists);
+	if (!sym_browser) {
+		ret = -ENOMEM;
+		goto out_reset;
+	}
+
+	/* Reset abort key so we can receive Ctrl-C as a key. */
+	SLang_reset_tty();
+	SLang_init_tty(0, 0, 0);
+	SLtty_set_suspend_state(true);
+
+	while (1) {
+		c2c_function_browser__update_nr_entries(sym_browser);
+		key = hist_browser__run(&sym_browser->hb, "? - help", true, 0);
+
+		switch (key) {
+		case 'q':
+		case K_TAB:
+		case K_ESC:
+		case CTRL('c'):
+			goto browser_done;
+		case 'd':
+			/* Cacheline detail honors the user's callchain setting. */
+			symbol_conf.use_callchain = saved_use_callchain;
+			c2c_function_browser__browse_cacheline_detail(sym_browser->hb.he_selection);
+			/* Preserve any toggle made in the detail view, then
+			 * re-disable callchain for the function view.
+			 */
+			saved_use_callchain = symbol_conf.use_callchain;
+			symbol_conf.use_callchain = false;
+			break;
+		case '?':
+			ui_browser__help_window(&sym_browser->hb.b, help);
+			break;
+		default:
+			break;
+		}
+	}
+
+browser_done:
+	c2c_function_browser__delete(sym_browser);
+out_reset:
+	c2c_function_hists__reset();
+out:
+	symbol_conf.use_callchain = saved_use_callchain;
+	return ret;
+}
-- 
2.52.0