Message-Id: <1489080941-3965-7-git-send-email-treeze.taeung@gmail.com>
Date:   Fri, 10 Mar 2017 02:35:40 +0900
From:   Taeung Song <treeze.taeung@...il.com>
To:     Arnaldo Carvalho de Melo <acme@...nel.org>
Cc:     linux-kernel@...r.kernel.org, Jiri Olsa <jolsa@...nel.org>,
        Namhyung Kim <namhyung@...nel.org>,
        Ingo Molnar <mingo@...nel.org>,
        Peter Zijlstra <peterz@...radead.org>,
        Wang Nan <wangnan0@...wei.com>,
        Masami Hiramatsu <mhiramat@...nel.org>,
        Taeung Song <treeze.taeung@...il.com>,
        Jiri Olsa <jolsa@...hat.com>
Subject: [PATCH v3 6/7] perf annotate: Introduce --source-only option

Currently there is an asm view that can show
parts of source code lines with --source option.

But I think it is nice to add the new view with
--source-only into perf-annotate.
The option can show acutal source code per symbol(function)
with overhead using new struct source_code.

I think this view can be more readable than previous source
code view and be the new view point for performance
for a precheck before assembly code level.

For example, if target symbol is 'hex2u64' of util/util.c

Before:

    $ perf annotate --stdio -s hex2u64
 Percent |      Source code & Disassembly of perf for cycles:ppp (42 samples)
-----------------------------------------------------------------------------
...
         :      int hex2u64(const char *ptr, u64 *long_val)
         :      {
    0.00 :        53feb3:       push   %rbp
    2.38 :        53feb4:       mov    %rsp,%rbp
    0.00 :        53feb7:       sub    $0x30,%rsp
    0.00 :        53febb:       callq  4248b0 <pthread_attr_setdetachstate@...+0x10>
    0.00 :        53fec0:       mov    %rdi,-0x28(%rbp)
    0.00 :        53fec4:       mov    %rsi,-0x30(%rbp)
    0.00 :        53fec8:       mov    %fs:0x28,%rax
    0.00 :        53fed1:       mov    %rax,-0x8(%rbp)
    0.00 :        53fed5:       xor    %eax,%eax
         :              const char *p = ptr;
    2.38 :        53fed7:       mov    -0x28(%rbp),%rax
    0.00 :        53fedb:       mov    %rax,-0x10(%rbp)
...

After:

    $ perf annotate --source-only --stdio -s hex2u64
 Percent |      Source code of util.c for cycles:ppp (42 samples)
-----------------------------------------------------------------
    0.00 : 354   * While we find nice hex chars, build a long_val.
    0.00 : 355   * Return number of chars processed.
    0.00 : 356   */
    0.00 : 357  int hex2u64(const char *ptr, u64 *long_val)
    2.38 : 358  {
    2.38 : 359          const char *p = ptr;
    0.00 : 360          *long_val = 0;
    0.00 : 361
   30.95 : 362          while (*p) {
   23.81 : 363                  const int hex_val = hex(*p);
    0.00 : 364
   14.29 : 365                  if (hex_val < 0)
    0.00 : 366                          break;
    0.00 : 367
   26.19 : 368                  *long_val = (*long_val << 4) | hex_val;
    0.00 : 369                  p++;
    0.00 : 370          }
    0.00 : 371
    0.00 : 372          return p - ptr;
    0.00 : 373  }

Cc: Namhyung Kim <namhyung@...nel.org>
Cc: Jiri Olsa <jolsa@...hat.com>
Signed-off-by: Taeung Song <treeze.taeung@...il.com>
---
 tools/perf/builtin-annotate.c     |   2 +
 tools/perf/ui/browsers/annotate.c |   5 -
 tools/perf/util/annotate.c        | 299 +++++++++++++++++++++++++++++++++++++-
 tools/perf/util/annotate.h        |  22 +++
 tools/perf/util/symbol.c          |   1 +
 tools/perf/util/symbol.h          |   1 +
 6 files changed, 321 insertions(+), 9 deletions(-)

diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 4f52d85..93365e1 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -432,6 +432,8 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
 		     symbol__config_symfs),
 	OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src,
 		    "Interleave source code with assembly code (default)"),
+	OPT_BOOLEAN(0, "source-only", &symbol_conf.annotate_src_only,
+		    "Display source code for each symbol"),
 	OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
 		    "Display raw encoding of assembly instructions (default)"),
 	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index ba36aac..03b2012 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -11,11 +11,6 @@
 #include "../../util/config.h"
 #include <pthread.h>
 
-struct disasm_line_samples {
-	double		percent;
-	u64		nr;
-};
-
 #define IPC_WIDTH 6
 #define CYCLES_WIDTH 6
 
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index a50d949..7d1c7cc 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -1357,6 +1357,273 @@ static const char *annotate__norm_arch(const char *arch_name)
 	return normalize_arch((char *)arch_name);
 }
 
+static int parse_srcline(char *srcline, char **path, int *line_nr)
+{
+	char *sep;
+
+	if (srcline == NULL || !strcmp(srcline, SRCLINE_UNKNOWN))
+		return -1;
+
+	sep = strchr(srcline, ':');
+	if (sep) {
+		*sep = '\0';
+		*path = srcline;
+		*line_nr = strtoul(++sep, NULL, 0);
+	} else
+		return -1;
+
+	return 0;
+}
+
+static void code_line__free(struct code_line *cl)
+{
+	zfree(&cl->line);
+	zfree(&cl->matched_dl_arr);
+	zfree(&cl->samples_sum);
+	free(cl);
+}
+
+static void code_lines__free(struct list_head *code_lines)
+{
+	struct code_line *pos, *tmp;
+
+	if (list_empty(code_lines))
+		return;
+
+	list_for_each_entry_safe(pos, tmp, code_lines, node) {
+		list_del_init(&pos->node);
+		code_line__free(pos);
+	}
+}
+
+static int symbol__free_source_code(struct symbol *sym)
+{
+	struct annotation *notes = symbol__annotation(sym);
+	struct source_code *code = notes->src->code;
+
+	if (code == NULL)
+		return -1;
+
+	code_lines__free(&code->lines);
+	zfree(&code->path);
+	zfree(&notes->src->code);
+	return 0;
+}
+
+static void code_line__sum_samples(struct code_line *cl, struct disasm_line *dl,
+				   struct annotation *notes, struct perf_evsel *evsel)
+{
+	int i;
+	u64 nr_samples;
+	struct sym_hist *h;
+	struct source_code *code = notes->src->code;
+
+	for (i = 0; i < code->nr_events; i++) {
+		double percent = 0.0;
+
+		h = annotation__histogram(notes, evsel->idx + i);
+		nr_samples = h->addr[dl->offset];
+		if (h->sum)
+			percent = 100.0 * nr_samples / h->sum;
+
+		cl->samples_sum[i].percent += percent;
+		cl->samples_sum[i].nr += nr_samples;
+	}
+}
+
+static void source_code__print(struct code_line *cl, int nr_events,
+			       struct annotation *notes, struct perf_evsel *evsel)
+{
+	int i;
+	const char *color;
+	double percent, max_percent = 0.0;
+
+	for (i = 0; i < cl->nr_matched_dl; i++) {
+		code_line__sum_samples(cl, cl->matched_dl_arr[i], notes, evsel);
+	}
+
+	for (i = 0; i < nr_events; i++) {
+		percent = cl->samples_sum[i].percent;
+		color = get_percent_color(percent);
+		if (max_percent < percent)
+			max_percent = percent;
+
+		if (symbol_conf.show_total_period)
+			color_fprintf(stdout, color, " %7" PRIu64,
+				      cl->samples_sum[i].nr);
+		else
+			color_fprintf(stdout, color, " %7.2f", percent);
+	}
+	color = get_percent_color(max_percent);
+	color_fprintf(stdout, color, " : %d	%s\n",
+		      cl->line_nr, cl->line);
+}
+
+static int code_line__match_with_dl(struct code_line *cl, struct list_head *disasm_lines)
+{
+	int nr_dl = 0;
+	struct disasm_line *pos, **tmp, **matched_dl_arr;
+	size_t allocated = sizeof(struct disasm_line **);
+
+	matched_dl_arr = zalloc(allocated);
+	if (!matched_dl_arr)
+		return -1;
+
+	list_for_each_entry(pos, disasm_lines, node) {
+		if (pos->line_nr == cl->line_nr) {
+			if (nr_dl > 0) {
+				tmp = realloc(matched_dl_arr, allocated * (nr_dl + 1));
+				if (!tmp) {
+					free(matched_dl_arr);
+					return -1;
+				}
+				matched_dl_arr = tmp;
+			}
+			matched_dl_arr[nr_dl++] = pos;
+		}
+	}
+
+	cl->matched_dl_arr = matched_dl_arr;
+	cl->nr_matched_dl = nr_dl;
+	return 0;
+}
+
+static struct code_line *code_line__new(char *line, int linenr, int nr_events)
+{
+	struct code_line *cl = zalloc(sizeof(*cl));
+
+	if (!cl)
+		return NULL;
+
+	cl->line_nr = linenr;
+	cl->line = strdup(line);
+	cl->samples_sum =
+		zalloc(sizeof(struct disasm_line_samples) * nr_events);
+	if (!cl->samples_sum)
+		zfree(&cl);
+
+	return cl;
+}
+
+static int source_code__collect(struct source_code *code,
+				struct annotation *notes,
+				char *path, char* d_name,
+				int start_linenr, int end_linenr)
+{
+	int ret = -1, linenr = 0;
+	char *line = NULL, *parsed_line;
+	size_t len;
+	FILE *file;
+	struct stat srcfile_st, objfile_st;
+	struct code_line *cl;
+
+	if (stat(path, &srcfile_st) < 0)
+		return -1;
+	else {
+		if (stat(d_name, &objfile_st) < 0)
+			return -1;
+		if (srcfile_st.st_mtime > objfile_st.st_mtime) {
+			pr_err("Source file is more recent than when recording"
+				   ": %s\n", path);
+			pr_err("  (try 'perf record' again after recompiling"
+			       " the source file or with 'perf buildid-cache -r')\n");
+			return -1;
+		}
+	}
+
+	file = fopen(path, "r");
+	if (!file)
+		return -1;
+
+	if (srcline_full_filename)
+		code->path = strdup(path);
+	else
+		code->path = strdup(basename(path));
+
+	INIT_LIST_HEAD(&code->lines);
+	while (!feof(file)) {
+		if (getline(&line, &len, file) < 0)
+			goto out_err;
+
+		if (++linenr < start_linenr)
+			continue;
+
+		parsed_line = rtrim(line);
+		cl = code_line__new(parsed_line, linenr, code->nr_events);
+		if (!cl)
+			goto out_err;
+		if (code_line__match_with_dl(cl, &notes->src->source) < 0)
+			goto out_err;
+
+		list_add_tail(&cl->node, &code->lines);
+		if (linenr == end_linenr) {
+			ret = 0;
+			goto out;
+		}
+	}
+out_err:
+	code_lines__free(&code->lines);
+out:
+	free(line);
+	fclose(file);
+	return ret;
+}
+
+static int symbol__get_source_code(struct symbol *sym, struct map *map,
+				   struct perf_evsel *evsel)
+{
+	struct annotation *notes = symbol__annotation(sym);
+	struct source_code *code;
+	bool tmp;
+	u64 start = map__rip_2objdump(map, sym->start);
+	u64 end = map__rip_2objdump(map, sym->end - 1);
+	int start_linenr, end_linenr, ret = -1;
+	char *path, *start_srcline = NULL, *end_srcline = NULL;
+	char *d_name = map->dso->symsrc_filename;
+
+	if (!d_name)
+		return -1;
+
+	tmp = srcline_full_filename;
+	srcline_full_filename = true;
+	start_srcline = get_srcline(map->dso, start, NULL, false);
+	end_srcline = get_srcline(map->dso, end, NULL, false);
+	srcline_full_filename = tmp;
+
+	if (parse_srcline(start_srcline, &path, &start_linenr) < 0)
+		goto out;
+	if (parse_srcline(end_srcline, &path, &end_linenr) < 0)
+		goto out;
+
+	code = zalloc(sizeof(struct source_code));
+	if (code == NULL)
+		goto out;
+
+	if (perf_evsel__is_group_event(evsel))
+		code->nr_events = evsel->nr_members;
+	else
+		code->nr_events = 1;
+
+	/* To read a function header for the sym */
+	if (start_linenr > 4)
+		start_linenr -= 4;
+	else
+		start_linenr = 1;
+
+	if (source_code__collect(code, notes, path, d_name,
+				 start_linenr, end_linenr) < 0) {
+		zfree(&code);
+		goto out;
+	}
+
+	ret = 0;
+	notes->src->code = code;
+out:
+	free_srcline(start_srcline);
+	free_srcline(end_srcline);
+	return ret;
+}
+
 int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_name, size_t privsize)
 {
 	struct dso *dso = map->dso;
@@ -1497,7 +1764,6 @@ int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_na
 
 	if (nline == 0)
 		pr_err("No output from %s\n", command);
-
 	/*
 	 * kallsyms does not have symbol sizes so there may a nop at the end.
 	 * Remove it.
@@ -1755,6 +2021,7 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map,
 	struct sym_hist *h = annotation__histogram(notes, evsel->idx);
 	struct disasm_line *pos, *queue = NULL;
 	u64 start = map__rip_2objdump(map, sym->start);
+	bool src_code_only = false;
 	int printed = 2, queue_len = 0;
 	int more = 0;
 	u64 len;
@@ -1775,8 +2042,14 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map,
 	if (perf_evsel__is_group_event(evsel))
 		width *= evsel->nr_members;
 
-	graph_dotted_len = printf(" %-*.*s|	Source code & Disassembly of %s for %s (%" PRIu64 " samples)\n",
-	       width, width, "Percent", d_filename, evsel_name, h->sum);
+	if (symbol_conf.annotate_src_only && notes->src->has_src_code)
+		src_code_only = true;
+
+	graph_dotted_len = printf(" %-*.*s|	%s of %s for %s (%" PRIu64 " samples)\n",
+				  width, width, "Percent",
+				  src_code_only ? "Source code" : "Source code & Disassembly",
+				  src_code_only ? notes->src->code->path : d_filename,
+				  evsel_name, h->sum);
 
 	printf("%-*.*s----\n",
 	       graph_dotted_len, graph_dotted_len, graph_dotted_line);
@@ -1784,6 +2057,16 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map,
 	if (verbose > 0)
 		symbol__annotate_hits(sym, evsel);
 
+	if (src_code_only) {
+		struct source_code *code = notes->src->code;
+		struct code_line *cl;
+
+		list_for_each_entry(cl, &code->lines, node)
+			source_code__print(cl, code->nr_events, notes, evsel);
+
+		goto out;
+	}
+
 	list_for_each_entry(pos, &notes->src->source, node) {
 		if (context && queue == NULL) {
 			queue = pos;
@@ -1820,7 +2103,8 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map,
 			break;
 		}
 	}
-
+out:
+	printf("\n");
 	free(filename);
 
 	return more;
@@ -1890,6 +2174,7 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map,
 			 bool full_paths, int min_pcnt, int max_lines)
 {
 	struct dso *dso = map->dso;
+	struct annotation *notes = symbol__annotation(sym);
 	struct rb_root source_line = RB_ROOT;
 	u64 len;
 
@@ -1904,11 +2189,17 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map,
 		print_summary(&source_line, dso->long_name);
 	}
 
+	if (symbol_conf.annotate_src_only &&
+	    symbol__get_source_code(sym, map, evsel) == 0)
+		notes->src->has_src_code = true;
+
 	symbol__annotate_printf(sym, map, evsel, full_paths,
 				min_pcnt, max_lines, 0);
 	if (print_lines)
 		symbol__free_source_line(sym, len);
 
+	if (notes->src->has_src_code)
+		symbol__free_source_code(sym);
 	disasm__purge(&symbol__annotation(sym)->src->source);
 
 	return 0;
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index 948aa8e..dd7ddae 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -56,6 +56,11 @@ int ins__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *
 
 struct annotation;
 
+struct disasm_line_samples {
+	double		percent;
+	u64		nr;
+};
+
 struct disasm_line {
 	struct list_head    node;
 	s64		    offset;
@@ -95,6 +100,21 @@ struct cyc_hist {
 	u16	reset;
 };
 
+struct code_line {
+	struct list_head    node;
+	int		    line_nr;
+	char		    *line;
+	int		    nr_matched_dl;
+	struct disasm_line  **matched_dl_arr;
+	struct disasm_line_samples *samples_sum;
+};
+
+struct source_code {
+	char		 *path;
+	int		 nr_events;
+	struct list_head lines;
+};
+
 struct source_line_samples {
 	double		percent;
 	double		percent_sum;
@@ -123,7 +143,9 @@ struct source_line {
  */
 struct annotated_source {
 	struct list_head   source;
+	struct source_code *code;
 	struct source_line *lines;
+	bool   		   has_src_code;
 	int    		   nr_histograms;
 	size_t		   sizeof_sym_hist;
 	struct cyc_hist	   *cycles_hist;
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 70e389b..71228bd 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -35,6 +35,7 @@ struct symbol_conf symbol_conf = {
 	.use_modules		= true,
 	.try_vmlinux_path	= true,
 	.annotate_src		= true,
+	.annotate_src_only	= false,
 	.demangle		= true,
 	.demangle_kernel	= false,
 	.cumulate_callchain	= true,
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 6c358b7..190be1d 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -108,6 +108,7 @@ struct symbol_conf {
 			kptr_restrict,
 			annotate_asm_raw,
 			annotate_src,
+			annotate_src_only,
 			event_group,
 			demangle,
 			demangle_kernel,
-- 
2.7.4

Powered by blists - more mailing lists