AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2025-02-22 23:30:27 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

perf report: Tag branch type/flag on "to" and tag cycles on "from"

Browse Source 
Current --branch-history LBR annotation displays confused data. For
example, each cycles report is duplicated on both "from" and "to"
entries.

For example:

  perf report --branch-history --no-children --stdio

  --2.32%--main div.c:39 (COND_BWD CROSS_2M predicted:49.7% cycles:1)
            main div.c:44 (predicted:49.7% cycles:1)
            main div.c:42 (RET CROSS_2M cycles:2)
            compute_flag div.c:28 (cycles:2)
            compute_flag div.c:27 (RET CROSS_2M cycles:1)
            rand rand.c:28 (cycles:1)
            rand rand.c:28 (RET CROSS_2M cycles:1)
            __random random.c:298 (cycles:1)
            __random random.c:297 (COND_BWD CROSS_2M cycles:1)
            __random random.c:295 (cycles:1)
            __random random.c:295 (COND_BWD CROSS_2M cycles:1)
            __random random.c:295 (cycles:1)
            __random random.c:295 (RET CROSS_2M cycles:9)

The cycles should be tagged only on the "from". It's for the code block
that ends with "from", not for "to".

Another issue is the "predicted:49.7%" is duplicated too (tag on both
"from" and "to").

This patch tags the branch type/flag on "to" and tag the cycles on
"from".

For example:

  --2.32%--main div.c:39 (COND_BWD CROSS_2M predicted:49.7%)
            main div.c:44 (cycles:1)
            main div.c:42 (RET CROSS_2M)
            compute_flag div.c:28 (cycles:2)
            compute_flag div.c:27 (RET CROSS_2M)
            rand rand.c:28 (cycles:1)
            rand rand.c:28 (RET CROSS_2M)
            __random random.c:298 (cycles:1)
            __random random.c:297 (COND_BWD CROSS_2M)
            __random random.c:295 (cycles:1)
            __random random.c:295 (COND_BWD CROSS_2M)
            __random random.c:295 (cycles:1)
            __random random.c:295 (RET CROSS_2M)
            |
             --2.23%--__random_r random_r.c:392 (cycles:9)

In this example, The "main div.c:39 (COND_BWD CROSS_2M predicted:49.7%)"
is "to" of branch and "main div.c:44 (cycles:1)" is "from" of branch.
It should be easier for understanding than before.

Signed-off-by: Yao Jin <yao.jin@linux.intel.com>
Reviewed-by: Andi Kleen <ak@linux.intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Kan Liang <kan.liang@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1500894547-18411-1-git-send-email-yao.jin@linux.intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
This commit is contained in:
Jin Yao 2017-07-24 19:09:07 +08:00 committed by Arnaldo Carvalho de Melo
parent b49a821ed9
commit a1a8bed32d
2 changed files with 105 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
tools/perf/util/branch.h
View File

@ -5,11 +5,12 @@
#include "../perf.h" #include "../perf.h"
struct branch_type_stat { struct branch_type_stat {
u64 counts[PERF_BR_MAX]; bool branch_to;
u64 cond_fwd; u64 counts[PERF_BR_MAX];
u64 cond_bwd; u64 cond_fwd;
u64 cross_4k; u64 cond_bwd;
u64 cross_2m; u64 cross_4k;
u64 cross_2m;
}; };
struct branch_flags; struct branch_flags;

136
tools/perf/util/callchain.c
View File

@ -563,20 +563,33 @@ fill_node(struct callchain_node *node, struct callchain_cursor *cursor)
if (cursor_node->branch) { if (cursor_node->branch) {
call->branch_count = 1; call->branch_count = 1;
if (cursor_node->branch_flags.predicted) if (cursor_node->branch_from) {
call->predicted_count = 1; /*
* branch_from is set with value somewhere else
* to imply it's "to" of a branch.
*/
call->brtype_stat.branch_to = true;
if (cursor_node->branch_flags.abort) if (cursor_node->branch_flags.predicted)
call->abort_count = 1; call->predicted_count = 1;
call->cycles_count = cursor_node->branch_flags.cycles; if (cursor_node->branch_flags.abort)
call->iter_count = cursor_node->nr_loop_iter; call->abort_count = 1;
call->samples_count = cursor_node->samples;
branch_type_count(&call->brtype_stat, branch_type_count(&call->brtype_stat,
&cursor_node->branch_flags, &cursor_node->branch_flags,
cursor_node->branch_from, cursor_node->branch_from,
cursor_node->ip); cursor_node->ip);
} else {
/*
* It's "from" of a branch
*/
call->brtype_stat.branch_to = false;
call->cycles_count =
cursor_node->branch_flags.cycles;
call->iter_count = cursor_node->nr_loop_iter;
call->samples_count = cursor_node->samples;
}
} }
list_add_tail(&call->list, &node->val); list_add_tail(&call->list, &node->val);
@ -685,20 +698,32 @@ static enum match_result match_chain(struct callchain_cursor_node *node,
if (node->branch) { if (node->branch) {
cnode->branch_count++; cnode->branch_count++;
if (node->branch_flags.predicted) if (node->branch_from) {
cnode->predicted_count++; /*
* It's "to" of a branch
*/
cnode->brtype_stat.branch_to = true;
if (node->branch_flags.abort) if (node->branch_flags.predicted)
cnode->abort_count++; cnode->predicted_count++;
cnode->cycles_count += node->branch_flags.cycles; if (node->branch_flags.abort)
cnode->iter_count += node->nr_loop_iter; cnode->abort_count++;
cnode->samples_count += node->samples;
branch_type_count(&cnode->brtype_stat, branch_type_count(&cnode->brtype_stat,
&node->branch_flags, &node->branch_flags,
node->branch_from, node->branch_from,
node->ip); node->ip);
} else {
/*
* It's "from" of a branch
*/
cnode->brtype_stat.branch_to = false;
cnode->cycles_count +=
node->branch_flags.cycles;
cnode->iter_count += node->nr_loop_iter;
cnode->samples_count += node->samples;
}
} }
return MATCH_EQ; return MATCH_EQ;
@ -1236,27 +1261,26 @@ static int count_pri64_printf(int idx, const char *str, u64 value, char *bf, int
return printed; return printed;
} }
static int count_float_printf(int idx, const char *str, float value, char *bf, int bfsize) static int count_float_printf(int idx, const char *str, float value,
char *bf, int bfsize, float threshold)
{ {
int printed; int printed;
if (threshold != 0.0 && value < threshold)
return 0;
printed = scnprintf(bf, bfsize, "%s%s:%.1f%%", (idx) ? " " : " (", str, value); printed = scnprintf(bf, bfsize, "%s%s:%.1f%%", (idx) ? " " : " (", str, value);
return printed; return printed;
} }
static int counts_str_build(char *bf, int bfsize, static int branch_to_str(char *bf, int bfsize,
u64 branch_count, u64 predicted_count, u64 branch_count, u64 predicted_count,
u64 abort_count, u64 cycles_count, u64 abort_count,
u64 iter_count, u64 samples_count, struct branch_type_stat *brtype_stat)
struct branch_type_stat *brtype_stat)
{ {
u64 cycles;
int printed, i = 0; int printed, i = 0;
if (branch_count == 0)
return scnprintf(bf, bfsize, " (calltrace)");
printed = branch_type_str(brtype_stat, bf, bfsize); printed = branch_type_str(brtype_stat, bf, bfsize);
if (printed) if (printed)
i++; i++;
@ -1264,15 +1288,29 @@ static int counts_str_build(char *bf, int bfsize,
if (predicted_count < branch_count) { if (predicted_count < branch_count) {
printed += count_float_printf(i++, "predicted", printed += count_float_printf(i++, "predicted",
predicted_count * 100.0 / branch_count, predicted_count * 100.0 / branch_count,
bf + printed, bfsize - printed); bf + printed, bfsize - printed, 0.0);
} }
if (abort_count) { if (abort_count) {
printed += count_float_printf(i++, "abort", printed += count_float_printf(i++, "abort",
abort_count * 100.0 / branch_count, abort_count * 100.0 / branch_count,
bf + printed, bfsize - printed); bf + printed, bfsize - printed, 0.1);
} }
if (i)
printed += scnprintf(bf + printed, bfsize - printed, ")");
return printed;
}
static int branch_from_str(char *bf, int bfsize,
u64 branch_count,
u64 cycles_count, u64 iter_count,
u64 samples_count)
{
int printed = 0, i = 0;
u64 cycles;
cycles = cycles_count / branch_count; cycles = cycles_count / branch_count;
if (cycles) { if (cycles) {
printed += count_pri64_printf(i++, "cycles", printed += count_pri64_printf(i++, "cycles",
@ -1287,10 +1325,34 @@ static int counts_str_build(char *bf, int bfsize,
} }
if (i) if (i)
return scnprintf(bf + printed, bfsize - printed, ")"); printed += scnprintf(bf + printed, bfsize - printed, ")");
bf[0] = 0; return printed;
return 0; }
static int counts_str_build(char *bf, int bfsize,
u64 branch_count, u64 predicted_count,
u64 abort_count, u64 cycles_count,
u64 iter_count, u64 samples_count,
struct branch_type_stat *brtype_stat)
{
int printed;
if (branch_count == 0)
return scnprintf(bf, bfsize, " (calltrace)");
if (brtype_stat->branch_to) {
printed = branch_to_str(bf, bfsize, branch_count,
predicted_count, abort_count, brtype_stat);
} else {
printed = branch_from_str(bf, bfsize, branch_count,
cycles_count, iter_count, samples_count);
}
if (!printed)
bf[0] = 0;
return printed;
} }
static int callchain_counts_printf(FILE *fp, char *bf, int bfsize, static int callchain_counts_printf(FILE *fp, char *bf, int bfsize,