perf: add support for sampling taken branches

Quoted 4 lines · Stephane Eranian

arch/arm/kernel/perf_event.c +0 -0

@@ -539,6 +539,10 @@ static int armpmu_event_init(struct perf_event *event)
         int err = 0;
         atomic_t *active_events = &armpmu->active_events;
 

arch/arm/kernel/perf_event.c static int armpmu_event_init(struct perf_event *event) · line 546

Quoted 5 lines

arch/arm/kernel/perf_event.c +4 -0

+       /* does not support taken branch sampling */
+       if (has_branch_smpl(event))
+               return -EOPNOTSUPP;
+
         if (armpmu->map_event(event) == -ENOENT)

I'll make that has_branch_stack(), ok? :-)

From: Roberto Agostino Vitillo <[email protected]>

This patch adds:
- ability to parse samples with PERF_SAMPLE_BRANCH_STACK
- sort on branches
- build histograms on branches

Signed-off-by Roberto Agostino Vitillo <[email protected]>

Signed-off-by Stephane Eranian <[email protected]>

---
 tools/perf/perf.h          |   17 ++
 tools/perf/util/annotate.c |    2 +-
 tools/perf/util/event.h    |    1 +
 tools/perf/util/evsel.c    |   10 ++
 tools/perf/util/hist.c     |   93 +++++++++---
 tools/perf/util/hist.h     |    7 +
 tools/perf/util/session.c  |   72 +++++++++
 tools/perf/util/session.h  |    4 +
 tools/perf/util/sort.c     |  362 +++++++++++++++++++++++++++++++++-----------
 tools/perf/util/sort.h     |    5 +
 tools/perf/util/symbol.h   |   13 ++
 11 files changed, 475 insertions(+), 111 deletions(-)

tools/perf/perf.h +17 -0

index 92af168..8b4d25d 100644
@@ -180,6 +180,23 @@ struct ip_callchain {
 	u64 ips[0];
 };
 
+struct branch_flags {
+	u64 mispred:1;
+	u64 predicted:1;
+	u64 reserved:62;
+};
+
+struct branch_entry {
+	u64				from;
+	u64				to;
+	struct branch_flags flags;
+};
+
+struct branch_stack {
+	u64				nr;
+	struct branch_entry	entries[0];
+};
+
 extern bool perf_host, perf_guest;
 extern const char perf_version_string[];
 

tools/perf/util/annotate.c +0 -0

index 011ed26..8248d80 100644

tools/perf/util/annotate.c +0 -0

 		return 0;
 
 	offset = addr - sym->start;

tools/perf/util/event.h +1 -0

index cbdeaad..1b19728 100644
@@ -81,6 +81,7 @@ struct perf_sample {
 	u32 raw_size;
 	void *raw_data;
 	struct ip_callchain *callchain;
+	struct branch_stack *branch_stack;
 };
 
 #define BUILD_ID_SIZE 20

tools/perf/util/evsel.c +0 -0

index dcfefab..6b15cda 100644
@@ -575,6 +575,16 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
 		data->raw_data = (void *) pdata;

tools/perf/util/evsel.c +2 -0

+		array += sz;
+	}
 	return 0;
 }
 

tools/perf/util/hist.c +0 -0

index 6f505d1..66f9936 100644

tools/perf/util/hist.c +24 -17

+		hists__new_col_len(hists, HISTC_SYMBOL, symlen);
+	} else {
 		const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
 
 		if (hists__col_len(hists, HISTC_DSO) < unresolved_col_width &&

@@ -195,26 +197,14 @@ static u8 symbol__parent_filter(const struct symbol *parent)
 	return 0;
 }
 
-struct hist_entry *__hists__add_entry(struct hists *hists,
+static struct hist_entry *add_hist_entry(struct hists *hists,
+				      struct hist_entry *entry,
 				      struct addr_location *al,
-				      struct symbol *sym_parent, u64 period)
+				      u64 period)
 {
 	struct rb_node **p;
 	struct rb_node *parent = NULL;
 	struct hist_entry *he;
-	struct hist_entry entry = {
-		.thread	= al->thread,
-		.ms = {
-			.map	= al->map,
-			.sym	= al->sym,
-		},
-		.cpu	= al->cpu,
-		.ip	= al->addr,
-		.level	= al->level,
-		.period	= period,
-		.parent = sym_parent,
-		.filtered = symbol__parent_filter(sym_parent),
-	};
 	int cmp;
 
 	pthread_mutex_lock(&hists->lock);

@@ -225,7 +215,7 @@ struct hist_entry *__hists__add_entry(struct hists *hists,
 		parent = *p;
 		he = rb_entry(parent, struct hist_entry, rb_node_in);
 
-		cmp = hist_entry__cmp(&entry, he);
+		cmp = hist_entry__cmp(entry, he);
 
 		if (!cmp) {
 			he->period += period;

@@ -239,7 +229,7 @@ struct hist_entry *__hists__add_entry(struct hists *hists,
 			p = &(*p)->rb_right;
 	}
 
-	he = hist_entry__new(&entry);
+	he = hist_entry__new(entry);
 	if (!he)
 		goto out_unlock;
 

@@ -252,6 +242,69 @@ struct hist_entry *__hists__add_entry(struct hists *hists,
 	return he;
 }
 
+struct hist_entry *__hists__add_branch_entry(struct hists *self,
+					     struct addr_location *al,
+					     struct symbol *sym_parent,
+					     struct branch_info *bi,
+					     u64 period){
+	struct hist_entry entry = {
+		.thread	= al->thread,
+		.ms = {
+			.map	= bi->to.map,
+			.sym	= bi->to.sym,
+		},
+		.cpu	= al->cpu,
+		.ip	= bi->to.addr,
+		.level	= al->level,
+		.period	= period,
+		.parent = sym_parent,
+		.filtered = symbol__parent_filter(sym_parent),

tools/perf/util/hist.c +36 -0

+	 * but instead what is in branch_info. The addresses and
+	 * symbols there may need wider columns, so make sure they
+	 * are taken into account.
+	 *
+	 * hists__calc_col_len() tracks the max column width, so
+	 * we need to call it for both the from and to addresses
+	 */
+	entry.ip     = bi->from.addr;
+	entry.ms.map = bi->from.map;
+	entry.ms.sym = bi->from.sym;
+	hists__calc_col_len(self, &entry);
+
+	return he;
+}
+
+struct hist_entry *__hists__add_entry(struct hists *self,
+				      struct addr_location *al,
+				      struct symbol *sym_parent, u64 period)
+{
+	struct hist_entry entry = {
+		.thread	= al->thread,
+		.ms = {
+			.map	= al->map,
+			.sym	= al->sym,
+		},
+		.cpu	= al->cpu,
+		.ip	= al->addr,
+		.level	= al->level,
+		.period	= period,
+		.parent = sym_parent,
+		.filtered = symbol__parent_filter(sym_parent),
+	};
+
+	return add_hist_entry(self, &entry, al, period);
+}
+
 int64_t
 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
 {

tools/perf/util/hist.h +7 -0

index 0d48613..801a04e 100644
@@ -41,6 +41,7 @@ enum hist_column {
 	HISTC_COMM,
 	HISTC_PARENT,
 	HISTC_CPU,
+	HISTC_MISPREDICT,
 	HISTC_NR_COLS, /* Last entry */
 };
 

@@ -73,6 +74,12 @@ int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
 			 struct hists *hists);
 void hist_entry__free(struct hist_entry *);
 
+struct hist_entry *__hists__add_branch_entry(struct hists *self,
+					     struct addr_location *al,
+					     struct symbol *sym_parent,
+					     struct branch_info *bi,
+					     u64 period);
+
 void hists__output_resort(struct hists *self);
 void hists__output_resort_threaded(struct hists *hists);
 void hists__collapse_resort(struct hists *self);

tools/perf/util/session.c +12 -0

index 552c1c5..5ce3f31 100644
@@ -229,6 +229,63 @@ static bool symbol__match_parent_regex(struct symbol *sym)
 	return 0;
 }
 
+static const u8 cpumodes[] = {
+	PERF_RECORD_MISC_USER,
+	PERF_RECORD_MISC_KERNEL,
+	PERF_RECORD_MISC_GUEST_USER,
+	PERF_RECORD_MISC_GUEST_KERNEL
+};
+#define NCPUMODES (sizeof(cpumodes)/sizeof(u8))
+
+static void ip__resolve_ams(struct machine *self, struct thread *thread,
+			    struct addr_map_symbol *ams,
+			    u64 ip)
+{

tools/perf/util/session.c +47 -0

+		 * or else, the symbol is unknown
+		 */
+		thread__find_addr_location(thread, self, m, MAP__FUNCTION,
+				ip, &al, NULL);
+		if (al.sym)
+			goto found;
+	}
+found:
+	ams->addr = ip;
+	ams->sym = al.sym;
+	ams->map = al.map;
+}
+
+struct branch_info *perf_session__resolve_bstack(struct machine *self,
+						 struct thread *thr,
+						 struct branch_stack *bs)
+{
+	struct branch_info *bi;
+	unsigned int i;
+
+	bi = calloc(bs->nr, sizeof(struct branch_info));
+	if (!bi)
+		return NULL;
+
+	for (i = 0; i < bs->nr; i++) {
+		ip__resolve_ams(self, thr, &bi[i].to, bs->entries[i].to);
+		ip__resolve_ams(self, thr, &bi[i].from, bs->entries[i].from);
+		bi[i].flags = bs->entries[i].flags;
+	}
+	return bi;
+}
+
 int machine__resolve_callchain(struct machine *self, struct perf_evsel *evsel,
 			       struct thread *thread,
 			       struct ip_callchain *chain,

@@ -697,6 +754,18 @@ static void callchain__printf(struct perf_sample *sample)
 		       i, sample->callchain->ips[i]);
 }
 
+static void branch_stack__printf(struct perf_sample *sample)
+{
+	uint64_t i;
+
+	printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr);
+
+	for (i = 0; i < sample->branch_stack->nr; i++)
+		printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 "\n",
+			i, sample->branch_stack->entries[i].from,
+			sample->branch_stack->entries[i].to);
+}
+
 static void perf_session__print_tstamp(struct perf_session *session,
 				       union perf_event *event,
 				       struct perf_sample *sample)

@@ -744,6 +813,9 @@ static void dump_sample(struct perf_session *session, union perf_event *event,
 
 	if (session->sample_type & PERF_SAMPLE_CALLCHAIN)
 		callchain__printf(sample);
+
+	if (session->sample_type & PERF_SAMPLE_BRANCH_STACK)
+		branch_stack__printf(sample);
 }
 
 static struct machine *

tools/perf/util/session.h +4 -0

index c8d9017..accb5dc 100644
@@ -73,6 +73,10 @@ int perf_session__resolve_callchain(struct perf_session *self, struct perf_evsel
 				    struct ip_callchain *chain,
 				    struct symbol **parent);
 
+struct branch_info *perf_session__resolve_bstack(struct machine *self,
+						 struct thread *thread,
+						 struct branch_stack *bs);
+
 bool perf_session__has_traces(struct perf_session *self, const char *msg);
 
 void mem_bswap_64(void *src, int byte_size);

tools/perf/util/sort.c +23 -3

index 16da30d..1531989 100644
@@ -8,6 +8,7 @@ const char	default_sort_order[] = "comm,dso,symbol";
 const char	*sort_order = default_sort_order;
 int		sort__need_collapse = 0;
 int		sort__has_parent = 0;
+bool		sort__branch_mode;
 
 enum sort_type	sort__first_dimension;
 

@@ -94,6 +95,26 @@ static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
 	return repsep_snprintf(bf, size, "%*s", width, self->thread->comm);
 }
 
+static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
+{
+	struct dso *dso_l = map_l ? map_l->dso : NULL;
+	struct dso *dso_r = map_r ? map_r->dso : NULL;
+	const char *dso_name_l, *dso_name_r;
+
+	if (!dso_l || !dso_r)
+		return cmp_null(dso_l, dso_r);
+
+	if (verbose) {
+		dso_name_l = dso_l->long_name;
+		dso_name_r = dso_r->long_name;
+	} else {
+		dso_name_l = dso_l->short_name;
+		dso_name_r = dso_r->short_name;
+	}
+
+	return strcmp(dso_name_l, dso_name_r);
+}
+
 struct sort_entry sort_comm = {
 	.se_header	= "Command",
 	.se_cmp		= sort__comm_cmp,

@@ -107,36 +128,74 @@ struct sort_entry sort_comm = {
 static int64_t
 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 {
-	struct dso *dso_l = left->ms.map ? left->ms.map->dso : NULL;
-	struct dso *dso_r = right->ms.map ? right->ms.map->dso : NULL;
-	const char *dso_name_l, *dso_name_r;
+	return _sort__dso_cmp(left->ms.map, right->ms.map);
+}
 

tools/perf/util/sort.c +248 -79

+			      u64 ip_l, u64 ip_r)
+{
+	if (!sym_l || !sym_r)
+		return cmp_null(sym_l, sym_r);
+
+	if (sym_l == sym_r)
+		return 0;
+
+	if (sym_l)
+		ip_l = sym_l->start;
+	if (sym_r)
+		ip_r = sym_r->start;
+
+	return (int64_t)(ip_r - ip_l);
+}
+
+static int _hist_entry__dso_snprintf(struct map *map, char *bf,
+				     size_t size, unsigned int width)
+{
+	if (map && map->dso) {
+		const char *dso_name = !verbose ? map->dso->short_name :
+			map->dso->long_name;
+		return repsep_snprintf(bf, size, "%-*s", width, dso_name);
 	}
 
-	return strcmp(dso_name_l, dso_name_r);
+	return repsep_snprintf(bf, size, "%-*s", width, "[unknown]");
 }
 
 static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
 				    size_t size, unsigned int width)
 {
-	if (self->ms.map && self->ms.map->dso) {
-		const char *dso_name = !verbose ? self->ms.map->dso->short_name :
-						  self->ms.map->dso->long_name;
-		return repsep_snprintf(bf, size, "%-*s", width, dso_name);
+	return _hist_entry__dso_snprintf(self->ms.map, bf, size, width);
+}
+
+static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
+				     u64 ip, char level, char *bf, size_t size,
+				     unsigned int width __used)
+{
+	size_t ret = 0;
+
+	if (verbose) {
+		char o = map ? dso__symtab_origin(map->dso) : '!';
+		ret += repsep_snprintf(bf, size, "%-#*llx %c ",
+				       BITS_PER_LONG / 4, ip, o);
 	}
 
-	return repsep_snprintf(bf, size, "%-*s", width, "[unknown]");
+	ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
+	if (sym)
+		ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+				       width - ret,
+				       sym->name);
+	else {
+		size_t len = BITS_PER_LONG / 4;
+		ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
+				       len, ip);
+		ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+				       width - ret, "");
+	}
+
+	return ret;
 }
 
+
 struct sort_entry sort_dso = {
 	.se_header	= "Shared Object",
 	.se_cmp		= sort__dso_cmp,

@@ -144,8 +203,14 @@ struct sort_entry sort_dso = {
 	.se_width_idx	= HISTC_DSO,
 };
 
-/* --sort symbol */
+static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
+				    size_t size, unsigned int width __used)
+{
+	return _hist_entry__sym_snprintf(self->ms.map, self->ms.sym, self->ip,
+					 self->level, bf, size, width);
+}
 
+/* --sort symbol */
 static int64_t
 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 {

@@ -154,40 +219,10 @@ sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 	if (!left->ms.sym && !right->ms.sym)
 		return right->level - left->level;
 
-	if (!left->ms.sym || !right->ms.sym)
-		return cmp_null(left->ms.sym, right->ms.sym);
-
-	if (left->ms.sym == right->ms.sym)
-		return 0;
-
 	ip_l = left->ms.sym->start;
 	ip_r = right->ms.sym->start;
 
-	return (int64_t)(ip_r - ip_l);
-}
-
-static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
-				    size_t size, unsigned int width __used)
-{
-	size_t ret = 0;
-
-	if (verbose) {
-		char o = self->ms.map ? dso__symtab_origin(self->ms.map->dso) : '!';
-		ret += repsep_snprintf(bf, size, "%-#*llx %c ",
-				       BITS_PER_LONG / 4, self->ip, o);
-	}
-
-	if (!sort_dso.elide)
-		ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
-
-	if (self->ms.sym)
-		ret += repsep_snprintf(bf + ret, size - ret, "%s",
-				       self->ms.sym->name);
-	else
-		ret += repsep_snprintf(bf + ret, size - ret, "%-#*llx",
-				       BITS_PER_LONG / 4, self->ip);
-
-	return ret;
+	return _sort__sym_cmp(left->ms.sym, right->ms.sym, ip_l, ip_r);
 }
 
 struct sort_entry sort_sym = {

@@ -246,6 +281,135 @@ struct sort_entry sort_cpu = {
 	.se_width_idx	= HISTC_CPU,
 };
 
+static int64_t
+sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+	return _sort__dso_cmp(left->branch_info->from.map,
+			      right->branch_info->from.map);
+}
+
+static int hist_entry__dso_from_snprintf(struct hist_entry *self, char *bf,
+				    size_t size, unsigned int width)
+{
+	return _hist_entry__dso_snprintf(self->branch_info->from.map,
+					 bf, size, width);
+}
+
+struct sort_entry sort_dso_from = {
+	.se_header	= "Source Shared Object",
+	.se_cmp		= sort__dso_from_cmp,
+	.se_snprintf	= hist_entry__dso_from_snprintf,
+	.se_width_idx	= HISTC_DSO,
+};
+
+static int64_t
+sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+	return _sort__dso_cmp(left->branch_info->to.map,
+			      right->branch_info->to.map);
+}
+
+static int hist_entry__dso_to_snprintf(struct hist_entry *self, char *bf,
+				       size_t size, unsigned int width)
+{
+	return _hist_entry__dso_snprintf(self->branch_info->to.map,
+					 bf, size, width);
+}
+
+static int64_t
+sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+	struct addr_map_symbol *from_l = &left->branch_info->from;
+	struct addr_map_symbol *from_r = &right->branch_info->from;
+
+	if (!from_l->sym && !from_r->sym)
+		return right->level - left->level;
+
+	return _sort__sym_cmp(from_l->sym, from_r->sym, from_l->addr,
+			     from_r->addr);
+}
+
+static int64_t
+sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+	struct addr_map_symbol *to_l = &left->branch_info->to;
+	struct addr_map_symbol *to_r = &right->branch_info->to;
+
+	if (!to_l->sym && !to_r->sym)
+		return right->level - left->level;
+
+	return _sort__sym_cmp(to_l->sym, to_r->sym, to_l->addr, to_r->addr);
+}
+
+static int hist_entry__sym_from_snprintf(struct hist_entry *self, char *bf,
+				    size_t size, unsigned int width __used)
+{
+	struct addr_map_symbol *from = &self->branch_info->from;
+	return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
+					 self->level, bf, size, width);
+
+}
+
+static int hist_entry__sym_to_snprintf(struct hist_entry *self, char *bf,
+				    size_t size, unsigned int width __used)
+{
+	struct addr_map_symbol *to = &self->branch_info->to;
+	return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
+					 self->level, bf, size, width);
+
+}
+
+struct sort_entry sort_dso_to = {
+	.se_header	= "Target Shared Object",
+	.se_cmp		= sort__dso_to_cmp,
+	.se_snprintf	= hist_entry__dso_to_snprintf,
+	.se_width_idx	= HISTC_DSO,
+};
+
+struct sort_entry sort_sym_from = {
+	.se_header	= "Source Symbol",
+	.se_cmp		= sort__sym_from_cmp,
+	.se_snprintf	= hist_entry__sym_from_snprintf,
+	.se_width_idx	= HISTC_SYMBOL,
+};
+
+struct sort_entry sort_sym_to = {
+	.se_header	= "Target Symbol",
+	.se_cmp		= sort__sym_to_cmp,
+	.se_snprintf	= hist_entry__sym_to_snprintf,
+	.se_width_idx	= HISTC_SYMBOL,
+};
+
+static int64_t
+sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+	const unsigned char mp = left->branch_info->flags.mispred !=
+					right->branch_info->flags.mispred;
+	const unsigned char p = left->branch_info->flags.predicted !=
+					right->branch_info->flags.predicted;
+
+	return mp || p;
+}
+
+static int hist_entry__mispredict_snprintf(struct hist_entry *self, char *bf,
+				    size_t size, unsigned int width){
+	static const char *out = "N/A";
+
+	if (self->branch_info->flags.predicted)
+		out = "N";
+	else if (self->branch_info->flags.mispred)
+		out = "Y";
+
+	return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
+struct sort_entry sort_mispredict = {
+	.se_header	= "Branch Mispredicted",
+	.se_cmp		= sort__mispredict_cmp,
+	.se_snprintf	= hist_entry__mispredict_snprintf,
+	.se_width_idx	= HISTC_MISPREDICT,
+};
+
 struct sort_dimension {
 	const char		*name;
 	struct sort_entry	*entry;

@@ -253,14 +417,59 @@ struct sort_dimension {
 };
 
 static struct sort_dimension sort_dimensions[] = {
-	{ .name = "pid",	.entry = &sort_thread,	},
-	{ .name = "comm",	.entry = &sort_comm,	},
-	{ .name = "dso",	.entry = &sort_dso,	},
-	{ .name = "symbol",	.entry = &sort_sym,	},
-	{ .name = "parent",	.entry = &sort_parent,	},
-	{ .name = "cpu",	.entry = &sort_cpu,	},
+	{ .name = "pid",	.entry = &sort_thread,			},
+	{ .name = "comm",	.entry = &sort_comm,			},
+	{ .name = "dso",	.entry = &sort_dso,			},
+	{ .name = "dso_from",	.entry = &sort_dso_from, .taken = true	},
+	{ .name = "dso_to",	.entry = &sort_dso_to,	 .taken = true	},
+	{ .name = "symbol",	.entry = &sort_sym,			},
+	{ .name = "symbol_from",.entry = &sort_sym_from, .taken = true	},
+	{ .name = "symbol_to",	.entry = &sort_sym_to,	 .taken = true	},
+	{ .name = "parent",	.entry = &sort_parent,			},
+	{ .name = "cpu",	.entry = &sort_cpu,			},
+	{ .name = "mispredict", .entry = &sort_mispredict, },
 };
 
+static int _sort_dimension__add(struct sort_dimension *sd)
+{
+	if (sd->entry->se_collapse)
+		sort__need_collapse = 1;
+
+	if (sd->entry == &sort_parent) {
+		int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
+		if (ret) {
+			char err[BUFSIZ];
+
+			regerror(ret, &parent_regex, err, sizeof(err));
+			pr_err("Invalid regex: %s\n%s", parent_pattern, err);
+			return -EINVAL;
+		}
+		sort__has_parent = 1;
+	}
+
+	if (list_empty(&hist_entry__sort_list)) {
+		if (!strcmp(sd->name, "pid"))
+			sort__first_dimension = SORT_PID;
+		else if (!strcmp(sd->name, "comm"))
+			sort__first_dimension = SORT_COMM;
+		else if (!strcmp(sd->name, "dso"))
+			sort__first_dimension = SORT_DSO;
+		else if (!strcmp(sd->name, "symbol"))
+			sort__first_dimension = SORT_SYM;
+		else if (!strcmp(sd->name, "parent"))
+			sort__first_dimension = SORT_PARENT;
+		else if (!strcmp(sd->name, "cpu"))
+			sort__first_dimension = SORT_CPU;
+		else if (!strcmp(sd->name, "mispredict"))
+			sort__first_dimension = SORT_MISPREDICTED;
+	}
+
+	list_add_tail(&sd->entry->list, &hist_entry__sort_list);
+	sd->taken = 1;
+
+	return 0;
+}
+
 int sort_dimension__add(const char *tok)
 {
 	unsigned int i;

@@ -271,48 +480,21 @@ int sort_dimension__add(const char *tok)
 		if (strncasecmp(tok, sd->name, strlen(tok)))
 			continue;
 
-		if (sd->entry == &sort_parent) {
-			int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
-			if (ret) {
-				char err[BUFSIZ];
-
-				regerror(ret, &parent_regex, err, sizeof(err));
-				pr_err("Invalid regex: %s\n%s", parent_pattern, err);
-				return -EINVAL;
-			}
-			sort__has_parent = 1;
-		}
-
 		if (sd->taken)
 			return 0;
 
-		if (sd->entry->se_collapse)
-			sort__need_collapse = 1;
-
-		if (list_empty(&hist_entry__sort_list)) {
-			if (!strcmp(sd->name, "pid"))
-				sort__first_dimension = SORT_PID;
-			else if (!strcmp(sd->name, "comm"))
-				sort__first_dimension = SORT_COMM;
-			else if (!strcmp(sd->name, "dso"))
-				sort__first_dimension = SORT_DSO;
-			else if (!strcmp(sd->name, "symbol"))
-				sort__first_dimension = SORT_SYM;
-			else if (!strcmp(sd->name, "parent"))
-				sort__first_dimension = SORT_PARENT;
-			else if (!strcmp(sd->name, "cpu"))
-				sort__first_dimension = SORT_CPU;
-		}
-
-		list_add_tail(&sd->entry->list, &hist_entry__sort_list);
-		sd->taken = 1;
 
-		return 0;
+		if (sort__branch_mode && (sd->entry == &sort_dso ||
+					sd->entry == &sort_sym)){
+			int err = _sort_dimension__add(sd + 1);
+			return err ?: _sort_dimension__add(sd + 2);
+		} else if (sd->entry == &sort_mispredict && !sort__branch_mode)
+			break;
+		else
+			return _sort_dimension__add(sd);
 	}
-
 	return -ESRCH;
 }
-
 void setup_sorting(const char * const usagestr[], const struct option *opts)
 {
 	char *tmp, *tok, *str = strdup(sort_order);

tools/perf/util/sort.h +5 -0

index 3f67ae3..effcae1 100644
@@ -31,11 +31,14 @@ extern const char *parent_pattern;
 extern const char default_sort_order[];
 extern int sort__need_collapse;
 extern int sort__has_parent;
+extern bool sort__branch_mode;
 extern char *field_sep;
 extern struct sort_entry sort_comm;
 extern struct sort_entry sort_dso;
 extern struct sort_entry sort_sym;
 extern struct sort_entry sort_parent;
+extern struct sort_entry sort_lbr_dso;
+extern struct sort_entry sort_lbr_sym;
 extern enum sort_type sort__first_dimension;
 
 /**

@@ -72,6 +75,7 @@ struct hist_entry {
 		struct hist_entry *pair;
 		struct rb_root	  sorted_chain;
 	};
+	struct branch_info	*branch_info;
 	struct callchain_root	callchain[0];
 };
 

@@ -82,6 +86,7 @@ enum sort_type {
 	SORT_SYM,
 	SORT_PARENT,
 	SORT_CPU,
+	SORT_MISPREDICTED,
 };
 
 /*

tools/perf/util/symbol.h +13 -0

index 2a683d4..5866ce6 100644
@@ -5,6 +5,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include "map.h"
+#include "../perf.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
 #include <stdio.h>

@@ -120,6 +121,18 @@ struct map_symbol {
 	bool	      has_children;
 };
 
+struct addr_map_symbol {
+	struct map    *map;
+	struct symbol *sym;
+	u64	      addr;
+};
+
+struct branch_info {
+	struct addr_map_symbol from;
+	struct addr_map_symbol to;
+	struct branch_flags flags;
+};
+
 struct addr_location {
 	struct thread *thread;
 	struct map    *map;

Signature · 1 line

1.7.4.1

Em Thu, Feb 02, 2012 at 01:54:41PM +0100, Stephane Eranian escreveu:

Quoted 6 lines

From: Roberto Agostino Vitillo <[email protected]>

This patch adds:
- ability to parse samples with PERF_SAMPLE_BRANCH_STACK
- sort on branches
- build histograms on branches

Some comments below, mostly minor stuff, looks great work, thanks!

- Arnaldo

Quoted 50 lines

Signed-off-by Roberto Agostino Vitillo <[email protected]>

Signed-off-by Stephane Eranian <[email protected]>

---
 tools/perf/perf.h          |   17 ++
 tools/perf/util/annotate.c |    2 +-

 tools/perf/util/event.h    |    1 +
 tools/perf/util/evsel.c    |   10 ++
 tools/perf/util/hist.c     |   93 +++++++++---
 tools/perf/util/hist.h     |    7 +

 tools/perf/util/session.c  |   72 +++++++++ tools/perf/util/session.h  |    4 +
 tools/perf/util/sort.c     |  362 +++++++++++++++++++++++++++++++++----------- tools/perf/util/sort.h     |    5 +
 tools/perf/util/symbol.h   |   13 ++

 11 files changed, 475 insertions(+), 111 deletions(-)

tools/perf/perf.h +17 -0

index 92af168..8b4d25d 100644
@@ -180,6 +180,23 @@ struct ip_callchain {
       u64 ips[0];
  };
 
+struct branch_flags {
+     u64 mispred:1;
+     u64 predicted:1;
+     u64 reserved:62;
+};
+
+struct branch_entry {
+     u64                             from;
+     u64                             to;
+     struct branch_flags flags;
+};
+
+struct branch_stack {
+     u64                             nr;
+     struct branch_entry     entries[0];
+};
+
  extern bool perf_host, perf_guest;
  extern const char perf_version_string[];
 

tools/perf/util/annotate.c +0 -0

index 011ed26..8248d80 100644
@@ -64,7 +64,7 @@ int symbol__inc_addr_samples(struct symbol *sym, struct map *map,
 

tools/perf/util/annotate.c int symbol__inc_addr_samples(struct symbol *sym, struct map *map, · line 67

Quoted 4 lines

tools/perf/util/annotate.c +1 -1

       pr_debug3("%s: addr=%#" PRIx64 "\n", __func__, map->unmap_ip(map, addr));
 
-     if (addr >= sym->end)
+     if (addr >= sym->end || addr < sym->start)

This is not related to this, would be better to come in a separate patch with a proper explanation.

Quoted 21 lines

tools/perf/util/annotate.c +0 -0

               return 0;
 
       offset = addr - sym->start;

tools/perf/util/event.h +1 -0

index cbdeaad..1b19728 100644
@@ -81,6 +81,7 @@ struct perf_sample {
       u32 raw_size;
       void *raw_data;
       struct ip_callchain *callchain;
+     struct branch_stack *branch_stack;
  };
 
  #define BUILD_ID_SIZE 20

tools/perf/util/evsel.c +0 -0

index dcfefab..6b15cda 100644
@@ -575,6 +575,16 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
               data->raw_data = (void *) pdata;

tools/perf/util/evsel.c int perf_event__parse_sample(const union perf_event *event, u64 type, · line 585

Quoted 10 lines

tools/perf/util/evsel.c +8 -0

       }
 
+     if (type & PERF_SAMPLE_BRANCH_STACK) {
+             u64 sz;
+
+             data->branch_stack = (struct branch_stack *)array;
+             array++; /* nr */
+
+             sz = data->branch_stack->nr * sizeof(struct branch_entry);
+             sz /= sizeof(uint64_t);

Consistency here: use sizeof(u64), or better yet: sizeof(sz);

Quoted 13 lines

tools/perf/util/evsel.c +2 -0

+             array += sz;
+     }
       return 0;
  }
 

tools/perf/util/hist.c +0 -0

index 6f505d1..66f9936 100644
@@ -54,9 +54,11 @@ static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
  {
       u16 len;
 

tools/perf/util/hist.c static void hists__calc_col_len(struct hists *hists, struct hist_entry *h) · line 59

Quoted 6 lines

tools/perf/util/hist.c +3 -3

-     if (h->ms.sym)
-             hists__new_col_len(hists, HISTC_SYMBOL, h->ms.sym->namelen);
-     else {
+     if (h->ms.sym) {
+             int n = (int)h->ms.sym->namelen + 4;
+             int symlen = max(n, BITS_PER_LONG / 4 + 6);

What is the rationale here? Adding a comment will help

Quoted 74 lines

tools/perf/util/hist.c +2 -0

+             hists__new_col_len(hists, HISTC_SYMBOL, symlen);
+     } else {
               const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
 

              if (hists__col_len(hists, HISTC_DSO) < unresolved_col_width &&

tools/perf/util/hist.c +22 -17

@@ -195,26 +197,14 @@ static u8 symbol__parent_filter(const struct symbol *parent)
       return 0;
  }
 
-struct hist_entry *__hists__add_entry(struct hists *hists,
+static struct hist_entry *add_hist_entry(struct hists *hists,
+                                   struct hist_entry *entry,
                                     struct addr_location *al,
-                                   struct symbol *sym_parent, u64 period)
+                                   u64 period)
  {
       struct rb_node **p;
       struct rb_node *parent = NULL;
       struct hist_entry *he;
-     struct hist_entry entry = {
-             .thread = al->thread,
-             .ms = {
-                     .map    = al->map,
-                     .sym    = al->sym,
-             },
-             .cpu    = al->cpu,
-             .ip     = al->addr,
-             .level  = al->level,
-             .period = period,
-             .parent = sym_parent,
-             .filtered = symbol__parent_filter(sym_parent),
-     };
       int cmp;
 
       pthread_mutex_lock(&hists->lock);

@@ -225,7 +215,7 @@ struct hist_entry *__hists__add_entry(struct hists *hists,
               parent = *p;
               he = rb_entry(parent, struct hist_entry, rb_node_in);
 
-             cmp = hist_entry__cmp(&entry, he);
+             cmp = hist_entry__cmp(entry, he);
 
               if (!cmp) {
                       he->period += period;

@@ -239,7 +229,7 @@ struct hist_entry *__hists__add_entry(struct hists *hists,
                       p = &(*p)->rb_right;
       }
 
-     he = hist_entry__new(&entry);
+     he = hist_entry__new(entry);
       if (!he)
               goto out_unlock;
 

@@ -252,6 +242,69 @@ struct hist_entry *__hists__add_entry(struct hists *hists,
       return he;
  }
 
+struct hist_entry *__hists__add_branch_entry(struct hists *self,
+                                          struct addr_location *al,
+                                          struct symbol *sym_parent,
+                                          struct branch_info *bi,
+                                          u64 period){
+     struct hist_entry entry = {
+             .thread = al->thread,
+             .ms = {
+                     .map    = bi->to.map,
+                     .sym    = bi->to.sym,
+             },
+             .cpu    = al->cpu,
+             .ip     = bi->to.addr,
+             .level  = al->level,
+             .period = period,
+             .parent = sym_parent,
+             .filtered = symbol__parent_filter(sym_parent),

tools/perf/util/hist.c struct hist_entry *__hists__add_entry(struct hists *hists, · line 271

Quoted 10 lines

tools/perf/util/hist.c +10 -0

+             .branch_info = bi,
+     };
+     struct hist_entry *he;
+
+     he = add_hist_entry(self, &entry, al, period);
+     if (!he)
+             return NULL;
+
+     /*
+      * in branch mode, we do not display al->sym, al->addr

Really minor nit, but start with:  "In branch mode"

Quoted 84 lines

tools/perf/util/hist.c +36 -0

+      * but instead what is in branch_info. The addresses and
+      * symbols there may need wider columns, so make sure they
+      * are taken into account.
+      *
+      * hists__calc_col_len() tracks the max column width, so
+      * we need to call it for both the from and to addresses
+      */
+     entry.ip     = bi->from.addr;
+     entry.ms.map = bi->from.map;
+     entry.ms.sym = bi->from.sym;
+     hists__calc_col_len(self, &entry);
+
+     return he;
+}
+
+struct hist_entry *__hists__add_entry(struct hists *self,
+                                   struct addr_location *al,
+                                   struct symbol *sym_parent, u64 period)
+{
+     struct hist_entry entry = {
+             .thread = al->thread,
+             .ms = {
+                     .map    = al->map,
+                     .sym    = al->sym,
+             },
+             .cpu    = al->cpu,
+             .ip     = al->addr,
+             .level  = al->level,
+             .period = period,
+             .parent = sym_parent,
+             .filtered = symbol__parent_filter(sym_parent),
+     };
+
+     return add_hist_entry(self, &entry, al, period);
+}
+

 int64_t
 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right) {

tools/perf/util/hist.h +1 -0

index 0d48613..801a04e 100644
@@ -41,6 +41,7 @@ enum hist_column {
       HISTC_COMM,
       HISTC_PARENT,
       HISTC_CPU,
+     HISTC_MISPREDICT,

      HISTC_NR_COLS, /* Last entry */
 };

tools/perf/util/hist.h +6 -0

@@ -73,6 +74,12 @@ int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
                        struct hists *hists);
  void hist_entry__free(struct hist_entry *);
 
+struct hist_entry *__hists__add_branch_entry(struct hists *self,
+                                          struct addr_location *al,
+                                          struct symbol *sym_parent,
+                                          struct branch_info *bi,
+                                          u64 period);
+
  void hists__output_resort(struct hists *self);
  void hists__output_resort_threaded(struct hists *hists);
  void hists__collapse_resort(struct hists *self);

tools/perf/util/session.c +12 -0

index 552c1c5..5ce3f31 100644
@@ -229,6 +229,63 @@ static bool symbol__match_parent_regex(struct symbol *sym)
       return 0;
  }
 
+static const u8 cpumodes[] = {
+     PERF_RECORD_MISC_USER,
+     PERF_RECORD_MISC_KERNEL,
+     PERF_RECORD_MISC_GUEST_USER,
+     PERF_RECORD_MISC_GUEST_KERNEL
+};
+#define NCPUMODES (sizeof(cpumodes)/sizeof(u8))
+
+static void ip__resolve_ams(struct machine *self, struct thread *thread,
+                         struct addr_map_symbol *ams,
+                         u64 ip)
+{

tools/perf/util/session.c static bool symbol__match_parent_regex(struct symbol *sym) · line 253

Quoted 10 lines

tools/perf/util/session.c +10 -0

+     struct addr_location al;
+     size_t i;
+     u8 m;
+
+     memset(&al, 0, sizeof(al));
+
+     for (i = 0; i < NCPUMODES; i++) {
+             m = cpumodes[i];
+             /*
+              * we cannot use the header.misc hint to determine whether a

ditto

tools/perf/util/session.c static bool symbol__match_parent_regex(struct symbol *sym) · line 256

Quoted 3 lines

tools/perf/util/session.c +3 -0

+              * branch stack address is user, kernel, guest, hypervisor.
+              * Branches may straddle the kernel/user/hypervisor boundaries.
+              * Thus, we have to try * consecutively until we find a match

                                       ^ comment reflow artifact?

Quoted 131 lines

tools/perf/util/session.c +47 -0

+              * or else, the symbol is unknown
+              */
+             thread__find_addr_location(thread, self, m, MAP__FUNCTION,
+                             ip, &al, NULL);
+             if (al.sym)
+                     goto found;
+     }
+found:
+     ams->addr = ip;
+     ams->sym = al.sym;
+     ams->map = al.map;
+}
+
+struct branch_info *perf_session__resolve_bstack(struct machine *self,
+                                              struct thread *thr,
+                                              struct branch_stack *bs)
+{
+     struct branch_info *bi;
+     unsigned int i;
+
+     bi = calloc(bs->nr, sizeof(struct branch_info));
+     if (!bi)
+             return NULL;
+
+     for (i = 0; i < bs->nr; i++) {
+             ip__resolve_ams(self, thr, &bi[i].to, bs->entries[i].to);
+             ip__resolve_ams(self, thr, &bi[i].from, bs->entries[i].from);
+             bi[i].flags = bs->entries[i].flags;
+     }
+     return bi;
+}
+
  int machine__resolve_callchain(struct machine *self, struct perf_evsel *evsel,
                              struct thread *thread,
                              struct ip_callchain *chain,

@@ -697,6 +754,18 @@ static void callchain__printf(struct perf_sample *sample)
                      i, sample->callchain->ips[i]);
  }
 
+static void branch_stack__printf(struct perf_sample *sample)
+{
+     uint64_t i;
+
+     printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr);
+
+     for (i = 0; i < sample->branch_stack->nr; i++)
+             printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 "\n",
+                     i, sample->branch_stack->entries[i].from,
+                     sample->branch_stack->entries[i].to);
+}
+
  static void perf_session__print_tstamp(struct perf_session *session,
                                      union perf_event *event,
                                      struct perf_sample *sample)

@@ -744,6 +813,9 @@ static void dump_sample(struct perf_session *session, union perf_event *event,
 
       if (session->sample_type & PERF_SAMPLE_CALLCHAIN)
               callchain__printf(sample);
+
+     if (session->sample_type & PERF_SAMPLE_BRANCH_STACK)
+             branch_stack__printf(sample);
  }
 

 static struct machine *

tools/perf/util/session.h +4 -0

index c8d9017..accb5dc 100644
@@ -73,6 +73,10 @@ int perf_session__resolve_callchain(struct perf_session *self, struct perf_evsel
                                   struct ip_callchain *chain,
                                   struct symbol **parent);
 
+struct branch_info *perf_session__resolve_bstack(struct machine *self,
+                                              struct thread *thread,
+                                              struct branch_stack *bs);
+
  bool perf_session__has_traces(struct perf_session *self, const char *msg);
 
  void mem_bswap_64(void *src, int byte_size);

tools/perf/util/sort.c +21 -0

index 16da30d..1531989 100644
@@ -8,6 +8,7 @@ const char    default_sort_order[] = "comm,dso,symbol";
  const char   *sort_order = default_sort_order;
  int          sort__need_collapse = 0;
  int          sort__has_parent = 0;
+bool         sort__branch_mode;
 
  enum sort_type       sort__first_dimension;
 

@@ -94,6 +95,26 @@ static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
       return repsep_snprintf(bf, size, "%*s", width, self->thread->comm);
  }
 
+static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
+{
+     struct dso *dso_l = map_l ? map_l->dso : NULL;
+     struct dso *dso_r = map_r ? map_r->dso : NULL;
+     const char *dso_name_l, *dso_name_r;
+
+     if (!dso_l || !dso_r)
+             return cmp_null(dso_l, dso_r);
+
+     if (verbose) {
+             dso_name_l = dso_l->long_name;
+             dso_name_r = dso_r->long_name;
+     } else {
+             dso_name_l = dso_l->short_name;
+             dso_name_r = dso_r->short_name;
+     }
+
+     return strcmp(dso_name_l, dso_name_r);
+}
+
  struct sort_entry sort_comm = {
       .se_header      = "Command",
       .se_cmp         = sort__comm_cmp,

@@ -107,36 +128,74 @@ struct sort_entry sort_comm = {

 static int64_t
 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right) {
-     struct dso *dso_l = left->ms.map ? left->ms.map->dso : NULL;
-     struct dso *dso_r = right->ms.map ? right->ms.map->dso : NULL;
-     const char *dso_name_l, *dso_name_r;
+     return _sort__dso_cmp(left->ms.map, right->ms.map); +}

-     if (!dso_l || !dso_r)
-             return cmp_null(dso_l, dso_r);

Quoted 7 lines

-     if (verbose) {
-             dso_name_l = dso_l->long_name;
-             dso_name_r = dso_r->long_name;
-     } else {
-             dso_name_l = dso_l->short_name;
-             dso_name_r = dso_r->short_name;
+static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r,

We use double _ on the front with the same rationale as in the kernel, i.e. we we do a little bit less than what the non __ prefixed function does (locking, etc).

Quoted 449 lines

+                           u64 ip_l, u64 ip_r)

tools/perf/util/sort.c +22 -0

+{
+     if (!sym_l || !sym_r)
+             return cmp_null(sym_l, sym_r);
+
+     if (sym_l == sym_r)
+             return 0;
+
+     if (sym_l)
+             ip_l = sym_l->start;
+     if (sym_r)
+             ip_r = sym_r->start;
+
+     return (int64_t)(ip_r - ip_l);
+}
+
+static int _hist_entry__dso_snprintf(struct map *map, char *bf,
+                                  size_t size, unsigned int width)
+{
+     if (map && map->dso) {
+             const char *dso_name = !verbose ? map->dso->short_name :
+                     map->dso->long_name;
+             return repsep_snprintf(bf, size, "%-*s", width, dso_name);

      }

-     return strcmp(dso_name_l, dso_name_r);
+     return repsep_snprintf(bf, size, "%-*s", width, "[unknown]"); }

 static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf, size_t size, unsigned int width) {
-     if (self->ms.map && self->ms.map->dso) {
-             const char *dso_name = !verbose ? self->ms.map->dso->short_name :
-                                               self->ms.map->dso->long_name;
-             return repsep_snprintf(bf, size, "%-*s", width, dso_name);
+     return _hist_entry__dso_snprintf(self->ms.map, bf, size, width);

tools/perf/util/sort.c +12 -0

+}
+
+static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
+                                  u64 ip, char level, char *bf, size_t size,
+                                  unsigned int width __used)
+{
+     size_t ret = 0;
+
+     if (verbose) {
+             char o = map ? dso__symtab_origin(map->dso) : '!';
+             ret += repsep_snprintf(bf, size, "%-#*llx %c ",
+                                    BITS_PER_LONG / 4, ip, o);

      }

-     return repsep_snprintf(bf, size, "%-*s", width, "[unknown]");
+     ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
+     if (sym)
+             ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+                                    width - ret,
+                                    sym->name);
+     else {
+             size_t len = BITS_PER_LONG / 4;
+             ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
+                                    len, ip);
+             ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+                                    width - ret, "");
+     }
+
+     return ret;
 }

+
 struct sort_entry sort_dso = {
      .se_header      = "Shared Object",
      .se_cmp         = sort__dso_cmp,

tools/perf/util/sort.c +7 -1

@@ -144,8 +203,14 @@ struct sort_entry sort_dso = {
       .se_width_idx   = HISTC_DSO,
  };
 
-/* --sort symbol */
+static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
+                                 size_t size, unsigned int width __used)
+{
+     return _hist_entry__sym_snprintf(self->ms.map, self->ms.sym, self->ip,
+                                      self->level, bf, size, width);
+}
 
+/* --sort symbol */

 static int64_t
 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right) {

tools/perf/util/sort.c +189 -72

@@ -154,40 +219,10 @@ sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
       if (!left->ms.sym && !right->ms.sym)
               return right->level - left->level;
 
-     if (!left->ms.sym || !right->ms.sym)
-             return cmp_null(left->ms.sym, right->ms.sym);
-
-     if (left->ms.sym == right->ms.sym)
-             return 0;
-
       ip_l = left->ms.sym->start;
       ip_r = right->ms.sym->start;
 
-     return (int64_t)(ip_r - ip_l);
-}
-
-static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
-                                 size_t size, unsigned int width __used)
-{
-     size_t ret = 0;
-
-     if (verbose) {
-             char o = self->ms.map ? dso__symtab_origin(self->ms.map->dso) : '!';
-             ret += repsep_snprintf(bf, size, "%-#*llx %c ",
-                                    BITS_PER_LONG / 4, self->ip, o);
-     }
-
-     if (!sort_dso.elide)
-             ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
-
-     if (self->ms.sym)
-             ret += repsep_snprintf(bf + ret, size - ret, "%s",
-                                    self->ms.sym->name);
-     else
-             ret += repsep_snprintf(bf + ret, size - ret, "%-#*llx",
-                                    BITS_PER_LONG / 4, self->ip);
-
-     return ret;
+     return _sort__sym_cmp(left->ms.sym, right->ms.sym, ip_l, ip_r);
  }
 
  struct sort_entry sort_sym = {

@@ -246,6 +281,135 @@ struct sort_entry sort_cpu = {
       .se_width_idx   = HISTC_CPU,
  };
 
+static int64_t
+sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+     return _sort__dso_cmp(left->branch_info->from.map,
+                           right->branch_info->from.map);
+}
+
+static int hist_entry__dso_from_snprintf(struct hist_entry *self, char *bf,
+                                 size_t size, unsigned int width)
+{
+     return _hist_entry__dso_snprintf(self->branch_info->from.map,
+                                      bf, size, width);
+}
+
+struct sort_entry sort_dso_from = {
+     .se_header      = "Source Shared Object",
+     .se_cmp         = sort__dso_from_cmp,
+     .se_snprintf    = hist_entry__dso_from_snprintf,
+     .se_width_idx   = HISTC_DSO,
+};
+
+static int64_t
+sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+     return _sort__dso_cmp(left->branch_info->to.map,
+                           right->branch_info->to.map);
+}
+
+static int hist_entry__dso_to_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+     return _hist_entry__dso_snprintf(self->branch_info->to.map,
+                                      bf, size, width);
+}
+
+static int64_t
+sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+     struct addr_map_symbol *from_l = &left->branch_info->from;
+     struct addr_map_symbol *from_r = &right->branch_info->from;
+
+     if (!from_l->sym && !from_r->sym)
+             return right->level - left->level;
+
+     return _sort__sym_cmp(from_l->sym, from_r->sym, from_l->addr,
+                          from_r->addr);
+}
+
+static int64_t
+sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+     struct addr_map_symbol *to_l = &left->branch_info->to;
+     struct addr_map_symbol *to_r = &right->branch_info->to;
+
+     if (!to_l->sym && !to_r->sym)
+             return right->level - left->level;
+
+     return _sort__sym_cmp(to_l->sym, to_r->sym, to_l->addr, to_r->addr);
+}
+
+static int hist_entry__sym_from_snprintf(struct hist_entry *self, char *bf,
+                                 size_t size, unsigned int width __used)
+{
+     struct addr_map_symbol *from = &self->branch_info->from;
+     return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
+                                      self->level, bf, size, width);
+
+}
+
+static int hist_entry__sym_to_snprintf(struct hist_entry *self, char *bf,
+                                 size_t size, unsigned int width __used)
+{
+     struct addr_map_symbol *to = &self->branch_info->to;
+     return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
+                                      self->level, bf, size, width);
+
+}
+
+struct sort_entry sort_dso_to = {
+     .se_header      = "Target Shared Object",
+     .se_cmp         = sort__dso_to_cmp,
+     .se_snprintf    = hist_entry__dso_to_snprintf,
+     .se_width_idx   = HISTC_DSO,
+};
+
+struct sort_entry sort_sym_from = {
+     .se_header      = "Source Symbol",
+     .se_cmp         = sort__sym_from_cmp,
+     .se_snprintf    = hist_entry__sym_from_snprintf,
+     .se_width_idx   = HISTC_SYMBOL,
+};
+
+struct sort_entry sort_sym_to = {
+     .se_header      = "Target Symbol",
+     .se_cmp         = sort__sym_to_cmp,
+     .se_snprintf    = hist_entry__sym_to_snprintf,
+     .se_width_idx   = HISTC_SYMBOL,
+};
+
+static int64_t
+sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+     const unsigned char mp = left->branch_info->flags.mispred !=
+                                     right->branch_info->flags.mispred;
+     const unsigned char p = left->branch_info->flags.predicted !=
+                                     right->branch_info->flags.predicted;
+
+     return mp || p;
+}
+
+static int hist_entry__mispredict_snprintf(struct hist_entry *self, char *bf,
+                                 size_t size, unsigned int width){
+     static const char *out = "N/A";
+
+     if (self->branch_info->flags.predicted)
+             out = "N";
+     else if (self->branch_info->flags.mispred)
+             out = "Y";
+
+     return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
+struct sort_entry sort_mispredict = {
+     .se_header      = "Branch Mispredicted",
+     .se_cmp         = sort__mispredict_cmp,
+     .se_snprintf    = hist_entry__mispredict_snprintf,
+     .se_width_idx   = HISTC_MISPREDICT,
+};
+
  struct sort_dimension {
       const char              *name;
       struct sort_entry       *entry;

@@ -253,14 +417,59 @@ struct sort_dimension {
  };
 
  static struct sort_dimension sort_dimensions[] = {
-     { .name = "pid",        .entry = &sort_thread,  },
-     { .name = "comm",       .entry = &sort_comm,    },
-     { .name = "dso",        .entry = &sort_dso,     },
-     { .name = "symbol",     .entry = &sort_sym,     },
-     { .name = "parent",     .entry = &sort_parent,  },
-     { .name = "cpu",        .entry = &sort_cpu,     },
+     { .name = "pid",        .entry = &sort_thread,                  },
+     { .name = "comm",       .entry = &sort_comm,                    },
+     { .name = "dso",        .entry = &sort_dso,                     },
+     { .name = "dso_from",   .entry = &sort_dso_from, .taken = true  },
+     { .name = "dso_to",     .entry = &sort_dso_to,   .taken = true  },
+     { .name = "symbol",     .entry = &sort_sym,                     },
+     { .name = "symbol_from",.entry = &sort_sym_from, .taken = true  },
+     { .name = "symbol_to",  .entry = &sort_sym_to,   .taken = true  },
+     { .name = "parent",     .entry = &sort_parent,                  },
+     { .name = "cpu",        .entry = &sort_cpu,                     },
+     { .name = "mispredict", .entry = &sort_mispredict, },
  };
 
+static int _sort_dimension__add(struct sort_dimension *sd)
+{
+     if (sd->entry->se_collapse)
+             sort__need_collapse = 1;
+
+     if (sd->entry == &sort_parent) {
+             int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
+             if (ret) {
+                     char err[BUFSIZ];
+
+                     regerror(ret, &parent_regex, err, sizeof(err));
+                     pr_err("Invalid regex: %s\n%s", parent_pattern, err);
+                     return -EINVAL;
+             }
+             sort__has_parent = 1;
+     }
+
+     if (list_empty(&hist_entry__sort_list)) {
+             if (!strcmp(sd->name, "pid"))
+                     sort__first_dimension = SORT_PID;
+             else if (!strcmp(sd->name, "comm"))
+                     sort__first_dimension = SORT_COMM;
+             else if (!strcmp(sd->name, "dso"))
+                     sort__first_dimension = SORT_DSO;
+             else if (!strcmp(sd->name, "symbol"))
+                     sort__first_dimension = SORT_SYM;
+             else if (!strcmp(sd->name, "parent"))
+                     sort__first_dimension = SORT_PARENT;
+             else if (!strcmp(sd->name, "cpu"))
+                     sort__first_dimension = SORT_CPU;
+             else if (!strcmp(sd->name, "mispredict"))
+                     sort__first_dimension = SORT_MISPREDICTED;
+     }
+
+     list_add_tail(&sd->entry->list, &hist_entry__sort_list);
+     sd->taken = 1;
+
+     return 0;
+}
+
  int sort_dimension__add(const char *tok)
  {
       unsigned int i;

@@ -271,48 +480,21 @@ int sort_dimension__add(const char *tok)
               if (strncasecmp(tok, sd->name, strlen(tok)))
                       continue;
 
-             if (sd->entry == &sort_parent) {
-                     int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
-                     if (ret) {
-                             char err[BUFSIZ];
-
-                             regerror(ret, &parent_regex, err, sizeof(err));
-                             pr_err("Invalid regex: %s\n%s", parent_pattern, err);
-                             return -EINVAL;
-                     }
-                     sort__has_parent = 1;
-             }
-
               if (sd->taken)
                       return 0;
 
-             if (sd->entry->se_collapse)
-                     sort__need_collapse = 1;
-
-             if (list_empty(&hist_entry__sort_list)) {
-                     if (!strcmp(sd->name, "pid"))
-                             sort__first_dimension = SORT_PID;
-                     else if (!strcmp(sd->name, "comm"))
-                             sort__first_dimension = SORT_COMM;
-                     else if (!strcmp(sd->name, "dso"))
-                             sort__first_dimension = SORT_DSO;
-                     else if (!strcmp(sd->name, "symbol"))
-                             sort__first_dimension = SORT_SYM;
-                     else if (!strcmp(sd->name, "parent"))
-                             sort__first_dimension = SORT_PARENT;
-                     else if (!strcmp(sd->name, "cpu"))
-                             sort__first_dimension = SORT_CPU;
-             }
-
-             list_add_tail(&sd->entry->list, &hist_entry__sort_list);
-             sd->taken = 1;
 
-             return 0;
+             if (sort__branch_mode && (sd->entry == &sort_dso ||
+                                     sd->entry == &sort_sym)){
+                     int err = _sort_dimension__add(sd + 1);
+                     return err ?: _sort_dimension__add(sd + 2);
+             } else if (sd->entry == &sort_mispredict && !sort__branch_mode)
+                     break;
+             else
+                     return _sort_dimension__add(sd);
       }
-
       return -ESRCH;
  }
-
  void setup_sorting(const char * const usagestr[], const struct option *opts)
  {
       char *tmp, *tok, *str = strdup(sort_order);

tools/perf/util/sort.h +5 -0

index 3f67ae3..effcae1 100644
@@ -31,11 +31,14 @@ extern const char *parent_pattern;
  extern const char default_sort_order[];
  extern int sort__need_collapse;
  extern int sort__has_parent;
+extern bool sort__branch_mode;
  extern char *field_sep;
  extern struct sort_entry sort_comm;
  extern struct sort_entry sort_dso;
  extern struct sort_entry sort_sym;
  extern struct sort_entry sort_parent;
+extern struct sort_entry sort_lbr_dso;
+extern struct sort_entry sort_lbr_sym;
  extern enum sort_type sort__first_dimension;
 
  /**

@@ -72,6 +75,7 @@ struct hist_entry {
               struct hist_entry *pair;
               struct rb_root    sorted_chain;
       };
+     struct branch_info      *branch_info;
       struct callchain_root   callchain[0];
  };
 

@@ -82,6 +86,7 @@ enum sort_type {
       SORT_SYM,
       SORT_PARENT,
       SORT_CPU,
+     SORT_MISPREDICTED,
  };
 
  /*

tools/perf/util/symbol.h +10 -0

index 2a683d4..5866ce6 100644
@@ -5,6 +5,7 @@
  #include <stdbool.h>
  #include <stdint.h>
  #include "map.h"
+#include "../perf.h"
  #include <linux/list.h>
  #include <linux/rbtree.h>
  #include <stdio.h>

@@ -120,6 +121,18 @@ struct map_symbol {
       bool          has_children;
  };
 
+struct addr_map_symbol {
+     struct map    *map;
+     struct symbol *sym;
+     u64           addr;
+};
+
+struct branch_info {
+     struct addr_map_symbol from;
+     struct addr_map_symbol to;

Quoted 8 lines

tools/perf/util/symbol.h +3 -1

+     struct branch_flags flags;
+};
+
  struct addr_location {
       struct thread *thread;
       struct map    *map;
--

1.7.4.1

Quoted 4 lines

Quoted 4 lines

+++ b/tools/perf/util/annotate.c

tools/perf/util/annotate.c +0 -0

@@ -64,7 +64,7 @@ int symbol__inc_addr_samples(struct symbol *sym, struct map *map,
 
       pr_debug3("%s: addr=%#" PRIx64 "\n", __func__, map->unmap_ip(map, addr));

Quoted 5 lines

tools/perf/util/annotate.c int symbol__inc_addr_samples(struct symbol *sym, struct map *map, · line 67

Quoted 2 lines

tools/perf/util/annotate.c +1 -1

-     if (addr >= sym->end)
+     if (addr >= sym->end || addr < sym->start)

This is not related to this, would be better to come in a separate patch with a proper explanation.

You mean in this patchset or separately?

From: Roberto Agostino Vitillo <[email protected]>

This patch adds a new option to enable taken branch stack sampling, i.e., leverage the PERF_SAMPLE_BRANCH_STACK feature of perf_events.

There is a new option to active this mode: -b.
It is possible to pass a set of filters to select the type of branches to sample.

The following filters are available:
- any : any type of branches
- any_call : any function call or system call
- any_ret : any function return or system call return
- any_ind : any indirect branch
- u: only when the branch target is at the user level
- k: only when the branch target is in the kernel
- hv: only when the branch target is in the hypervisor

Filters can be combined by passing a comma separated list to the option:

$ perf record -b any_call,u -e cycles:u branchy

Signed-off-by Roberto Agostino Vitillo <[email protected]>

Signed-off-by Stephane Eranian <[email protected]>

---
 tools/perf/Documentation/perf-record.txt |   25 ++++++++++
 tools/perf/builtin-record.c              |   74 ++++++++++++++++++++++++++++++
 tools/perf/perf.h                        |    1 +
 tools/perf/util/evsel.c                  |    4 ++
 4 files changed, 104 insertions(+), 0 deletions(-)

tools/perf/Documentation/perf-record.txt +25 -0

index ff9a66e..288d429 100644
@@ -152,6 +152,31 @@ an empty cgroup (monitor all the time) using, e.g., -G foo,,bar. Cgroups must ha
 corresponding events, i.e., they always refer to events defined earlier on the command
 line.
 
+-b::
+--branch-stack::
+Enable taken branch stack sampling. Each sample captures a series of consecutive
+taken branches. The number of branches captured with each sample depends on the
+underlying hardware, the type of branches of interest, and the executed code.
+It is possible to select the types of branches captured by enabling filters. The
+following filters are defined:
+
+        -  any :  any type of branches
+        - any_call: any function call or system call
+        - any_ret: any function return or system call return
+        - any_ind: any indirect branch
+        - u:  only when the branch target is at the user level
+        - k: only when the branch target is in the kernel
+        - hv: only when the target is at the hypervisor level
+
++
+At least one of any, any_call, any_ret, any_ind must be provided. The privilege levels may
+be ommitted, in which case, the privilege levels of the associated event are applied to the
+branch filter. Both kernel (k) and hypervisor (hv) privilege levels are subject to
+permissions.  When sampling on multiple events, branch stack sampling is enabled for all
+the sampling events. The sampled branch type is the same for all events.
+Note that taken branch sampling may not be available on all processors.
+The various filters must be specified as a comma separated list: -b any_ret,u,k
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-list[1]

tools/perf/builtin-record.c +74 -0

index 32870ee..6565164 100644
@@ -637,6 +637,77 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
 	return err;
 }
 
+#define BRANCH_OPT(n, m) \
+	{ .name = n, .mode = (m) }
+
+#define BRANCH_END { .name = NULL }
+
+struct branch_mode {
+	const char *name;
+	int mode;
+};
+
+static const struct branch_mode branch_modes[] = {
+	BRANCH_OPT("u", PERF_SAMPLE_BRANCH_USER),
+	BRANCH_OPT("k", PERF_SAMPLE_BRANCH_KERNEL),
+	BRANCH_OPT("hv", PERF_SAMPLE_BRANCH_HV),
+	BRANCH_OPT("any", PERF_SAMPLE_BRANCH_ANY),
+	BRANCH_OPT("any_call", PERF_SAMPLE_BRANCH_ANY_CALL),
+	BRANCH_OPT("any_ret", PERF_SAMPLE_BRANCH_ANY_RETURN),
+	BRANCH_OPT("ind_call", PERF_SAMPLE_BRANCH_IND_CALL),
+	BRANCH_END
+};
+
+static int
+parse_branch_stack(const struct option *opt, const char *str, int unset __used)
+{
+#define ONLY_PLM \
+	(PERF_SAMPLE_BRANCH_USER	|\
+	 PERF_SAMPLE_BRANCH_KERNEL	|\
+	 PERF_SAMPLE_BRANCH_HV)
+
+	uint64_t *mode = (uint64_t *)opt->value;
+	const struct branch_mode *br;
+	char *s, *os, *p;
+	int ret = -1;
+
+	*mode = 0;
+
+	/* because str is read-only */
+	s = os = strdup(str);
+	if (!s)
+		return -1;
+
+	for (;;) {
+		p = strchr(s, ',');
+		if (p)
+			*p = '\0';
+
+		for (br = branch_modes; br->name; br++) {
+			if (!strcasecmp(s, br->name))
+				break;
+		}
+		if (!br->name)
+			goto error;
+
+		*mode |= br->mode;
+
+		if (!p)
+			break;
+
+		s = p + 1;
+	}
+	ret = 0;
+
+	if ((*mode & ~ONLY_PLM) == 0) {
+		error("need at least one branch type with -b\n");
+		ret = -1;
+	}
+error:
+	free(os);
+	return ret;
+}
+
 static const char * const record_usage[] = {
 	"perf record [<options>] [<command>]",
 	"perf record [<options>] -- <command> [<options>]",

@@ -729,6 +800,9 @@ const struct option record_options[] = {
 		     "monitor event in cgroup name only",
 		     parse_cgroups),
 	OPT_STRING('u', "uid", &record.uid_str, "user", "user to profile"),
+	OPT_CALLBACK('b', "branch-stack", &record.opts.branch_stack,
+		     "branch mode mask", "branch stack sampling modes",
+		     parse_branch_stack),
 	OPT_END()
 };
 

tools/perf/perf.h +1 -0

index 8b4d25d..7f8fbab 100644
@@ -222,6 +222,7 @@ struct perf_record_opts {
 	unsigned int freq;
 	unsigned int mmap_pages;
 	unsigned int user_freq;
+	int	     branch_stack;
 	u64	     default_interval;
 	u64	     user_interval;
 	const char   *cpu_list;

tools/perf/util/evsel.c +4 -0

index 6b15cda..63a6a16 100644
@@ -126,6 +126,10 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts)
 		attr->watermark = 0;
 		attr->wakeup_events = 1;
 	}
+	if (opts->branch_stack) {
+		attr->sample_type	|= PERF_SAMPLE_BRANCH_STACK;
+		attr->branch_sample_type = opts->branch_stack;
+	}
 
 	attr->mmap = track;
 	attr->comm = track;

Signature · 1 line

1.7.4.1

From: Roberto Agostino Vitillo <[email protected]>

This patch adds support for taken branch sampling, i.e, the PERF_SAMPLE_BRANCH_STACK feature to perf report. In other words, to display histograms based on taken branches rather than executed instructions addresses.

The new option is called -b and it takes no argument. To generate meaningful output, the perf.data must have been obtained using perf record -b xxx ... where xxx is a branch filter option.

The output shows symbols, modules, sorted by 'who branches where' the most often. The percentages reported in the first column refer to the total number of branches captured and not the usual number of samples.

Here is a quick example.
Here branchy is simple test program which looks as follows:

void f2(void)
{}
void f3(void)
{}
void f1(unsigned long n)
{
if (n & 1UL)

    f2();
  else
    f3();
}

int main(void)
{
unsigned long i;

for (i=0; i < N; i++)
f1(i);
return 0;
}

Here is the output captured on Nehalem, if we are
only interested in user level function calls.

$ perf record -b any_call,u -e cycles:u branchy

$ perf report -b --sort=symbol
    52.34%  [.] main                   [.] f1
    24.04%  [.] f1                     [.] f3
    23.60%  [.] f1                     [.] f2
     0.01%  [k] _IO_new_file_xsputn    [k] _IO_file_overflow
     0.01%  [k] _IO_vfprintf_internal  [k] _IO_new_file_xsputn
     0.01%  [k] _IO_vfprintf_internal  [k] strchrnul
     0.01%  [k] __printf               [k] _IO_vfprintf_internal
     0.01%  [k] main                   [k] __printf

About half (52%) of the call branches captured are from main() -> f1(). The second half (24%+23%) is split in two equal shares between f1() -> f2(), f1() ->f3(). The output is as expected given the code.

It should be noted, that using -b in perf record does not eliminate information in the perf.data file. Consequently, a typical profile can also be obtained by perf report by simply not using its -b option.

Signed-off-by Roberto Agostino Vitillo <[email protected]>

Signed-off-by Stephane Eranian <[email protected]>

---
 tools/perf/Documentation/perf-report.txt |    7 ++
 tools/perf/builtin-report.c              |   98 +++++++++++++++++++++++++++---
 2 files changed, 96 insertions(+), 9 deletions(-)

tools/perf/Documentation/perf-report.txt +7 -0

index 9b430e9..19b9092 100644
@@ -153,6 +153,13 @@ OPTIONS
 	information which may be very large and thus may clutter the display.
 	It currently includes: cpu and numa topology of the host system.
 
+-b::
+--branch-stack::
+	Use the addresses of sampled taken branches instead of the instruction
+	address to build the histograms. To generate meaningful output, the
+	perf.data file must have been obtained using perf record -b xxx where
+	xxx is a branch filter option.
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-annotate[1]

tools/perf/builtin-report.c +0 -0

index 25d34d4..8a8d2f9 100644

tools/perf/builtin-report.c +8 -0

+{
+	struct perf_report *rep = container_of(tool, struct perf_report, tool);
+	struct symbol *parent = NULL;
+	int err = 0;
+	unsigned i;
+	struct hist_entry *he;
+	struct branch_info *bi;
+

tools/perf/builtin-report.c +47 -7

+	if (!bi)
+		return -ENOMEM;
+
+	for (i = 0; i < sample->branch_stack->nr; i++) {
+		if (rep->hide_unresolved && !(bi[i].from.sym && bi[i].to.sym))
+			continue;
+		/*
+		 * The report shows the percentage of total branches captured
+		 * and not events sampled. Thus we use a pseudo period of 1.
+		 */
+		he = __hists__add_branch_entry(&evsel->hists, al, parent,
+					       &bi[i], 1);
+		if (he) {
+			evsel->hists.stats.total_period += 1;
+			hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
+		} else
+			return -ENOMEM;
+	}
+	return err;
+}
+
 static int perf_evsel__add_hist_entry(struct perf_evsel *evsel,
 				      struct addr_location *al,
 				      struct perf_sample *sample,

@@ -126,14 +170,21 @@ static int process_sample_event(struct perf_tool *tool,
 	if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap))
 		return 0;
 
-	if (al.map != NULL)
-		al.map->dso->hit = 1;
+	if (sort__branch_mode) {
+		if (perf_session__add_branch_hist_entry(tool, &al, sample,
+						    evsel, machine)) {
+			pr_debug("problem adding lbr entry, skipping event\n");
+			return -1;
+		}
+	} else {
+		if (al.map != NULL)
+			al.map->dso->hit = 1;
 
-	if (perf_evsel__add_hist_entry(evsel, &al, sample, machine)) {
-		pr_debug("problem incrementing symbol period, skipping event\n");
-		return -1;
+		if (perf_evsel__add_hist_entry(evsel, &al, sample, machine)) {
+			pr_debug("problem incrementing symbol period, skipping event\n");
+			return -1;
+		}
 	}
-
 	return 0;
 }
 

@@ -188,6 +239,15 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
 			}
 	}
 
+	if (sort__branch_mode) {
+		if (!(self->sample_type & PERF_SAMPLE_BRANCH_STACK)) {
+			fprintf(stderr, "selected -b but no branch data."
+					" Did you call perf record without"
+					" -b?\n");
+			return -1;
+		}
+	}
+
 	return 0;
 }
 

@@ -477,7 +537,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
 	OPT_BOOLEAN(0, "stdio", &report.use_stdio,
 		    "Use the stdio interface"),
 	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
-		   "sort by key(s): pid, comm, dso, symbol, parent"),
+		   "sort by key(s): pid, comm, dso, symbol, parent, dso_to,"
+		   " dso_from, symbol_to, symbol_from, mispredict"),
 	OPT_BOOLEAN(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,
 		    "Show sample percentage for different cpu modes"),
 	OPT_STRING('p', "parent", &parent_pattern, "regex",

@@ -517,6 +578,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
 		   "Specify disassembler style (e.g. -M intel for intel syntax)"),
 	OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
 		    "Show a column with the sum of periods"),
+	OPT_BOOLEAN('b', "branch-stack", &sort__branch_mode,
+		    "use branch records for histogram filling"),
 	OPT_END()
 	};
 

tools/perf/builtin-report.c +15 -1

+		if (symbol_conf.dso_list_str != NULL)
+			fprintf(stderr, "Warning: dso filtering not supported"
+					" in branch mode\n");
+		if (symbol_conf.sym_list_str != NULL)
+			fprintf(stderr, "Warning: symbol filtering not"
+					" supported in branch mode\n");
+
+		report.use_stdio = true;
+		use_browser = 0;
 		setup_browser(true);
-	else
+		symbol_conf.dso_list_str = NULL;
+		symbol_conf.sym_list_str = NULL;
+	} else if (strcmp(report.input_name, "-") != 0) {
+		setup_browser(true);
+	} else {
 		use_browser = 0;
+	}
 
 	/*
 	 * Only in the newt browser we are doing integrated annotation,

Signature · 1 line

1.7.4.1

The current version of perf detects whether or not the perf.data file is written in a different endianness using the attr_size field in the header of the file. This field represents sizeof(struct perf_event_attr) as known to perf record. If the sizes do not match, then perf tries the byte-swapped version. If they match, then the tool assumes a different endianness.

The issue with the approach is that it assumes the size of perf_event_attr always has to match between perf record and perf report. However, the kernel perf_event ABI is extensible. New fields can be added to struct perf_event_attr. Consequently, it is not possible to use attr_size to detect endianness.

This patch takes another approach by using the magic number written at the beginning of the perf.data file to detect endianness. The magic number is an eight-byte signature. It's primary purpose is to identify (signature) a perf.data file. But it could also be used to encode the endianness.

The patch introduces a new value for this signature. The key difference is that the signature is written differently in the file depending on the endianness. Thus, by comparing the signature from the file with the tool's own signature it is possible to detect endianness. The new signature is "PERFILE2".

Backward compatiblity with existing perf.data file is ensured.

Signed-off-by Stephane Eranian <[email protected]>

---
 tools/perf/util/header.c |   77 ++++++++++++++++++++++++++++++++++++++--------
 1 files changed, 64 insertions(+), 13 deletions(-)

tools/perf/util/header.c +64 -13

index ecd7f4d..6f4187d 100644
@@ -63,9 +63,20 @@ char *perf_header__find_event(u64 id)
 	return NULL;
 }
 
-static const char *__perf_magic = "PERFFILE";
+/*
+ * magic2 = "PERFILE2"
+ * must be a numerical value to let the endianness
+ * determine the memory layout. That way we are able
+ * to detect endianness when reading the perf.data file
+ * back.
+ *
+ * we check for legacy (PERFFILE) format.
+ */
+static const char *__perf_magic1 = "PERFFILE";
+static const u64 __perf_magic2    = 0x32454c4946524550ULL;
+static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
 
-#define PERF_MAGIC	(*(u64 *)__perf_magic)
+#define PERF_MAGIC	__perf_magic2
 
 struct perf_file_attr {
 	struct perf_event_attr	attr;

@@ -1620,24 +1631,59 @@ int perf_header__process_sections(struct perf_header *header, int fd,
 	return err;
 }
 
+static int check_magic_endian(u64 *magic, struct perf_file_header *header,
+			      struct perf_header *ph)
+{
+	int ret;
+
+	/* check for legacy format */
+	ret = memcmp(magic, __perf_magic1, sizeof(*magic));
+	if (ret == 0) {
+		pr_debug("legacy perf.data format\n");
+		if (!header)
+			return -1;
+
+		if (header->attr_size != sizeof(struct perf_file_attr)) {
+			u64 attr_size = bswap_64(header->attr_size);
+
+			if (attr_size != sizeof(struct perf_file_attr))
+				return -1;
+
+			ph->needs_swap = true;
+		}
+		return 0;
+	}
+
+	/* check magic number with same endianness */
+	if (*magic == __perf_magic2)
+		return 0;
+
+	/* check magic number but opposite endianness */
+	if (*magic != __perf_magic2_sw)
+		return -1;
+
+	ph->needs_swap = true;
+
+	return 0;
+}
+
 int perf_file_header__read(struct perf_file_header *header,
 			   struct perf_header *ph, int fd)
 {
+	int ret;
+
 	lseek(fd, 0, SEEK_SET);
 
-	if (readn(fd, header, sizeof(*header)) <= 0 ||
-	    memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
+	ret = readn(fd, header, sizeof(*header));
+	if (ret <= 0)
 		return -1;
 
-	if (header->attr_size != sizeof(struct perf_file_attr)) {
-		u64 attr_size = bswap_64(header->attr_size);
-
-		if (attr_size != sizeof(struct perf_file_attr))
-			return -1;
+	if (check_magic_endian(&header->magic, header, ph) < 0)
+		return -1;
 
+	if (ph->needs_swap) {
 		mem_bswap_64(header, offsetof(struct perf_file_header,
-					    adds_features));
-		ph->needs_swap = true;
+			     adds_features));
 	}
 
 	if (header->size != sizeof(*header)) {

@@ -1873,8 +1919,13 @@ static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
 				       struct perf_header *ph, int fd,
 				       bool repipe)
 {
-	if (readn(fd, header, sizeof(*header)) <= 0 ||
-	    memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
+	int ret;
+
+	ret = readn(fd, header, sizeof(*header));
+	if (ret <= 0)
+		return -1;
+
+	 if (check_magic_endian(&header->magic, NULL, ph) < 0)
 		return -1;
 
 	if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)

Signature · 1 line

1.7.4.1

Em Thu, Feb 02, 2012 at 01:54:44PM +0100, Stephane Eranian escreveu:

Quoted 26 lines

The current version of perf detects whether or not the perf.data file is written in a different endianness using the attr_size field in the header of the file. This field represents sizeof(struct perf_event_attr) as known to perf record. If the sizes do not match, then perf tries the byte-swapped version. If they match, then the tool assumes a different endianness.

The issue with the approach is that it assumes the size of perf_event_attr always has to match between perf record and perf report. However, the kernel perf_event ABI is extensible. New fields can be added to struct perf_event_attr. Consequently, it is not possible to use attr_size to detect endianness.

This patch takes another approach by using the magic number written at the beginning of the perf.data file to detect endianness. The magic number is an eight-byte signature. It's primary purpose is to identify (signature) a perf.data file. But it could also be used to encode the endianness.

The patch introduces a new value for this signature. The key difference is that the signature is written differently in the file depending on the endianness. Thus, by comparing the signature from the file with the tool's own signature it is possible to detect endianness. The new signature is "PERFILE2".