GitHub-Mirror/Star64_linux
2
0
Fork 0
mirror of https://github.com/Fishwaldo/Star64_linux.git synced 2025-07-23 15:27:29 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

perf stat: Print per-thread shadow stats

Browse source 
The function perf_stat__print_shadow_stats() is called to print the
shadow stats on a set of static variables.

But the static variables are the limitations to support
per-thread shadow stats.

This patch lets the perf_stat__print_shadow_stats() support
to print the shadow stats from a input parameter 'st'.

It will not directly get value from static variable. Instead,
it now uses runtime_stat_avg() and runtime_stat_n() to get and
compute the values.

Signed-off-by: Jin Yao <yao.jin@linux.intel.com>
Acked-by: Jiri Olsa <jolsa@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Kan Liang <kan.liang@intel.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1512482591-4646-6-git-send-email-yao.jin@linux.intel.com
[ Rename 'stat' variables to 'st' to build on centos:{5,6} and others where it shadows a global declaration ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
This commit is contained in:
Jin Yao 2017-12-05 22:03:05 +08:00 • committed by Arnaldo Carvalho de Melo
parent 1fcd03946b
commit e0128b30db
4 changed files with 151 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

3
tools/perf/builtin-script.c
View file

@ -1557,7 +1557,8 @@ static void perf_sample__fprint_metric(struct perf_script *script,
evsel_script(ev2)->val, evsel_script(ev2)->val,
sample->cpu, sample->cpu,
&ctx, &ctx,
NULL); NULL,
&rt_stat);
} }
evsel_script(evsel->leader)->gnum = 0; evsel_script(evsel->leader)->gnum = 0;
} }

23
tools/perf/builtin-stat.c
View file

@ -1097,7 +1097,8 @@ static void abs_printout(int id, int nr, struct perf_evsel *evsel, double avg)
} }
static void printout(int id, int nr, struct perf_evsel *counter, double uval, static void printout(int id, int nr, struct perf_evsel *counter, double uval,
char *prefix, u64 run, u64 ena, double noise) char *prefix, u64 run, u64 ena, double noise,
struct runtime_stat *st)
{ {
struct perf_stat_output_ctx out; struct perf_stat_output_ctx out;
struct outstate os = { struct outstate os = {
@ -1190,7 +1191,7 @@ static void printout(int id, int nr, struct perf_evsel *counter, double uval,
perf_stat__print_shadow_stats(counter, uval, perf_stat__print_shadow_stats(counter, uval,
first_shadow_cpu(counter, id), first_shadow_cpu(counter, id),
&out, &metric_events); &out, &metric_events, st);
if (!csv_output && !metric_only) { if (!csv_output && !metric_only) {
print_noise(counter, noise); print_noise(counter, noise);
print_running(run, ena); print_running(run, ena);
@ -1335,7 +1336,8 @@ static void print_aggr(char *prefix)
fprintf(output, "%s", prefix); fprintf(output, "%s", prefix);
uval = val * counter->scale; uval = val * counter->scale;
printout(id, nr, counter, uval, prefix, run, ena, 1.0); printout(id, nr, counter, uval, prefix, run, ena, 1.0,
&rt_stat);
if (!metric_only) if (!metric_only)
fputc('\n', output); fputc('\n', output);
} }
@ -1365,7 +1367,8 @@ static void print_aggr_thread(struct perf_evsel *counter, char *prefix)
fprintf(output, "%s", prefix); fprintf(output, "%s", prefix);
uval = val * counter->scale; uval = val * counter->scale;
printout(thread, 0, counter, uval, prefix, run, ena, 1.0); printout(thread, 0, counter, uval, prefix, run, ena, 1.0,
&rt_stat);
fputc('\n', output); fputc('\n', output);
} }
} }
@ -1402,7 +1405,8 @@ static void print_counter_aggr(struct perf_evsel *counter, char *prefix)
fprintf(output, "%s", prefix); fprintf(output, "%s", prefix);
uval = cd.avg * counter->scale; uval = cd.avg * counter->scale;
printout(-1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled, cd.avg); printout(-1, 0, counter, uval, prefix, cd.avg_running, cd.avg_enabled,
cd.avg, &rt_stat);
if (!metric_only) if (!metric_only)
fprintf(output, "\n"); fprintf(output, "\n");
} }
@ -1441,7 +1445,8 @@ static void print_counter(struct perf_evsel *counter, char *prefix)
fprintf(output, "%s", prefix); fprintf(output, "%s", prefix);
uval = val * counter->scale; uval = val * counter->scale;
printout(cpu, 0, counter, uval, prefix, run, ena, 1.0); printout(cpu, 0, counter, uval, prefix, run, ena, 1.0,
&rt_stat);
fputc('\n', output); fputc('\n', output);
} }
@ -1473,7 +1478,8 @@ static void print_no_aggr_metric(char *prefix)
run = perf_counts(counter->counts, cpu, 0)->run; run = perf_counts(counter->counts, cpu, 0)->run;
uval = val * counter->scale; uval = val * counter->scale;
printout(cpu, 0, counter, uval, prefix, run, ena, 1.0); printout(cpu, 0, counter, uval, prefix, run, ena, 1.0,
&rt_stat);
} }
fputc('\n', stat_config.output); fputc('\n', stat_config.output);
} }
@ -1529,7 +1535,8 @@ static void print_metric_headers(const char *prefix, bool no_indent)
perf_stat__print_shadow_stats(counter, 0, perf_stat__print_shadow_stats(counter, 0,
0, 0,
&out, &out,
&metric_events); &metric_events,
&rt_stat);
} }
fputc('\n', stat_config.output); fputc('\n', stat_config.output);
} }

209
tools/perf/util/stat-shadow.c
View file

@ -424,15 +424,40 @@ void perf_stat__collect_metric_expr(struct perf_evlist *evsel_list)
} }
} }
static double runtime_stat_avg(struct runtime_stat *st,
enum stat_type type, int ctx, int cpu)
{
struct saved_value *v;
v = saved_value_lookup(NULL, cpu, false, type, ctx, st);
if (!v)
return 0.0;
return avg_stats(&v->stats);
}
static double runtime_stat_n(struct runtime_stat *st,
enum stat_type type, int ctx, int cpu)
{
struct saved_value *v;
v = saved_value_lookup(NULL, cpu, false, type, ctx, st);
if (!v)
return 0.0;
return v->stats.n;
}
static void print_stalled_cycles_frontend(int cpu, static void print_stalled_cycles_frontend(int cpu,
struct perf_evsel *evsel, double avg, struct perf_evsel *evsel, double avg,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
double total, ratio = 0.0; double total, ratio = 0.0;
const char *color; const char *color;
int ctx = evsel_context(evsel); int ctx = evsel_context(evsel);
total = avg_stats(&runtime_cycles_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
if (total) if (total)
ratio = avg / total * 100.0; ratio = avg / total * 100.0;
@ -448,13 +473,14 @@ static void print_stalled_cycles_frontend(int cpu,
static void print_stalled_cycles_backend(int cpu, static void print_stalled_cycles_backend(int cpu,
struct perf_evsel *evsel, double avg, struct perf_evsel *evsel, double avg,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
double total, ratio = 0.0; double total, ratio = 0.0;
const char *color; const char *color;
int ctx = evsel_context(evsel); int ctx = evsel_context(evsel);
total = avg_stats(&runtime_cycles_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
if (total) if (total)
ratio = avg / total * 100.0; ratio = avg / total * 100.0;
@ -467,13 +493,14 @@ static void print_stalled_cycles_backend(int cpu,
static void print_branch_misses(int cpu, static void print_branch_misses(int cpu,
struct perf_evsel *evsel, struct perf_evsel *evsel,
double avg, double avg,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
double total, ratio = 0.0; double total, ratio = 0.0;
const char *color; const char *color;
int ctx = evsel_context(evsel); int ctx = evsel_context(evsel);
total = avg_stats(&runtime_branches_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_BRANCHES, ctx, cpu);
if (total) if (total)
ratio = avg / total * 100.0; ratio = avg / total * 100.0;
@ -486,13 +513,15 @@ static void print_branch_misses(int cpu,
static void print_l1_dcache_misses(int cpu, static void print_l1_dcache_misses(int cpu,
struct perf_evsel *evsel, struct perf_evsel *evsel,
double avg, double avg,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
double total, ratio = 0.0; double total, ratio = 0.0;
const char *color; const char *color;
int ctx = evsel_context(evsel); int ctx = evsel_context(evsel);
total = avg_stats(&runtime_l1_dcache_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_L1_DCACHE, ctx, cpu);
if (total) if (total)
ratio = avg / total * 100.0; ratio = avg / total * 100.0;
@ -505,13 +534,15 @@ static void print_l1_dcache_misses(int cpu,
static void print_l1_icache_misses(int cpu, static void print_l1_icache_misses(int cpu,
struct perf_evsel *evsel, struct perf_evsel *evsel,
double avg, double avg,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
double total, ratio = 0.0; double total, ratio = 0.0;
const char *color; const char *color;
int ctx = evsel_context(evsel); int ctx = evsel_context(evsel);
total = avg_stats(&runtime_l1_icache_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_L1_ICACHE, ctx, cpu);
if (total) if (total)
ratio = avg / total * 100.0; ratio = avg / total * 100.0;
@ -523,13 +554,14 @@ static void print_l1_icache_misses(int cpu,
static void print_dtlb_cache_misses(int cpu, static void print_dtlb_cache_misses(int cpu,
struct perf_evsel *evsel, struct perf_evsel *evsel,
double avg, double avg,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
double total, ratio = 0.0; double total, ratio = 0.0;
const char *color; const char *color;
int ctx = evsel_context(evsel); int ctx = evsel_context(evsel);
total = avg_stats(&runtime_dtlb_cache_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_DTLB_CACHE, ctx, cpu);
if (total) if (total)
ratio = avg / total * 100.0; ratio = avg / total * 100.0;
@ -541,13 +573,14 @@ static void print_dtlb_cache_misses(int cpu,
static void print_itlb_cache_misses(int cpu, static void print_itlb_cache_misses(int cpu,
struct perf_evsel *evsel, struct perf_evsel *evsel,
double avg, double avg,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
double total, ratio = 0.0; double total, ratio = 0.0;
const char *color; const char *color;
int ctx = evsel_context(evsel); int ctx = evsel_context(evsel);
total = avg_stats(&runtime_itlb_cache_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_ITLB_CACHE, ctx, cpu);
if (total) if (total)
ratio = avg / total * 100.0; ratio = avg / total * 100.0;
@ -559,13 +592,14 @@ static void print_itlb_cache_misses(int cpu,
static void print_ll_cache_misses(int cpu, static void print_ll_cache_misses(int cpu,
struct perf_evsel *evsel, struct perf_evsel *evsel,
double avg, double avg,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
double total, ratio = 0.0; double total, ratio = 0.0;
const char *color; const char *color;
int ctx = evsel_context(evsel); int ctx = evsel_context(evsel);
total = avg_stats(&runtime_ll_cache_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_LL_CACHE, ctx, cpu);
if (total) if (total)
ratio = avg / total * 100.0; ratio = avg / total * 100.0;
@ -623,68 +657,72 @@ static double sanitize_val(double x)
return x; return x;
} }
static double td_total_slots(int ctx, int cpu) static double td_total_slots(int ctx, int cpu, struct runtime_stat *st)
{ {
return avg_stats(&runtime_topdown_total_slots[ctx][cpu]); return runtime_stat_avg(st, STAT_TOPDOWN_TOTAL_SLOTS, ctx, cpu);
} }
static double td_bad_spec(int ctx, int cpu) static double td_bad_spec(int ctx, int cpu, struct runtime_stat *st)
{ {
double bad_spec = 0; double bad_spec = 0;
double total_slots; double total_slots;
double total; double total;
total = avg_stats(&runtime_topdown_slots_issued[ctx][cpu]) - total = runtime_stat_avg(st, STAT_TOPDOWN_SLOTS_ISSUED, ctx, cpu) -
avg_stats(&runtime_topdown_slots_retired[ctx][cpu]) + runtime_stat_avg(st, STAT_TOPDOWN_SLOTS_RETIRED, ctx, cpu) +
avg_stats(&runtime_topdown_recovery_bubbles[ctx][cpu]); runtime_stat_avg(st, STAT_TOPDOWN_RECOVERY_BUBBLES, ctx, cpu);
total_slots = td_total_slots(ctx, cpu);
total_slots = td_total_slots(ctx, cpu, st);
if (total_slots) if (total_slots)
bad_spec = total / total_slots; bad_spec = total / total_slots;
return sanitize_val(bad_spec); return sanitize_val(bad_spec);
} }
static double td_retiring(int ctx, int cpu) static double td_retiring(int ctx, int cpu, struct runtime_stat *st)
{ {
double retiring = 0; double retiring = 0;
double total_slots = td_total_slots(ctx, cpu); double total_slots = td_total_slots(ctx, cpu, st);
double ret_slots = avg_stats(&runtime_topdown_slots_retired[ctx][cpu]); double ret_slots = runtime_stat_avg(st, STAT_TOPDOWN_SLOTS_RETIRED,
ctx, cpu);
if (total_slots) if (total_slots)
retiring = ret_slots / total_slots; retiring = ret_slots / total_slots;
return retiring; return retiring;
} }
static double td_fe_bound(int ctx, int cpu) static double td_fe_bound(int ctx, int cpu, struct runtime_stat *st)
{ {
double fe_bound = 0; double fe_bound = 0;
double total_slots = td_total_slots(ctx, cpu); double total_slots = td_total_slots(ctx, cpu, st);
double fetch_bub = avg_stats(&runtime_topdown_fetch_bubbles[ctx][cpu]); double fetch_bub = runtime_stat_avg(st, STAT_TOPDOWN_FETCH_BUBBLES,
ctx, cpu);
if (total_slots) if (total_slots)
fe_bound = fetch_bub / total_slots; fe_bound = fetch_bub / total_slots;
return fe_bound; return fe_bound;
} }
static double td_be_bound(int ctx, int cpu) static double td_be_bound(int ctx, int cpu, struct runtime_stat *st)
{ {
double sum = (td_fe_bound(ctx, cpu) + double sum = (td_fe_bound(ctx, cpu, st) +
td_bad_spec(ctx, cpu) + td_bad_spec(ctx, cpu, st) +
td_retiring(ctx, cpu)); td_retiring(ctx, cpu, st));
if (sum == 0) if (sum == 0)
return 0; return 0;
return sanitize_val(1.0 - sum); return sanitize_val(1.0 - sum);
} }
static void print_smi_cost(int cpu, struct perf_evsel *evsel, static void print_smi_cost(int cpu, struct perf_evsel *evsel,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
double smi_num, aperf, cycles, cost = 0.0; double smi_num, aperf, cycles, cost = 0.0;
int ctx = evsel_context(evsel); int ctx = evsel_context(evsel);
const char *color = NULL; const char *color = NULL;
smi_num = avg_stats(&runtime_smi_num_stats[ctx][cpu]); smi_num = runtime_stat_avg(st, STAT_SMI_NUM, ctx, cpu);
aperf = avg_stats(&runtime_aperf_stats[ctx][cpu]); aperf = runtime_stat_avg(st, STAT_APERF, ctx, cpu);
cycles = avg_stats(&runtime_cycles_stats[ctx][cpu]); cycles = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
if ((cycles == 0) || (aperf == 0)) if ((cycles == 0) || (aperf == 0))
return; return;
@ -704,7 +742,8 @@ static void generic_metric(const char *metric_expr,
const char *metric_name, const char *metric_name,
double avg, double avg,
int cpu, int cpu,
struct perf_stat_output_ctx *out) struct perf_stat_output_ctx *out,
struct runtime_stat *st)
{ {
print_metric_t print_metric = out->print_metric; print_metric_t print_metric = out->print_metric;
struct parse_ctx pctx; struct parse_ctx pctx;
@ -724,7 +763,7 @@ static void generic_metric(const char *metric_expr,
scale = 1e-9; scale = 1e-9;
} else { } else {
v = saved_value_lookup(metric_events[i], cpu, false, v = saved_value_lookup(metric_events[i], cpu, false,
STAT_NONE, 0, &rt_stat); STAT_NONE, 0, st);
if (!v) if (!v)
break; break;
stats = &v->stats; stats = &v->stats;
@ -752,7 +791,8 @@ static void generic_metric(const char *metric_expr,
void perf_stat__print_shadow_stats(struct perf_evsel *evsel, void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
double avg, int cpu, double avg, int cpu,
struct perf_stat_output_ctx *out, struct perf_stat_output_ctx *out,
struct rblist *metric_events) struct rblist *metric_events,
struct runtime_stat *st)
{ {
void *ctxp = out->ctx; void *ctxp = out->ctx;
print_metric_t print_metric = out->print_metric; print_metric_t print_metric = out->print_metric;
@ -763,7 +803,8 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
int num = 1; int num = 1;
if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) { if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
total = avg_stats(&runtime_cycles_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
if (total) { if (total) {
ratio = avg / total; ratio = avg / total;
print_metric(ctxp, NULL, "%7.2f ", print_metric(ctxp, NULL, "%7.2f ",
@ -771,8 +812,13 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
} else { } else {
print_metric(ctxp, NULL, NULL, "insn per cycle", 0); print_metric(ctxp, NULL, NULL, "insn per cycle", 0);
} }
total = avg_stats(&runtime_stalled_cycles_front_stats[ctx][cpu]);
total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[ctx][cpu])); total = runtime_stat_avg(st, STAT_STALLED_CYCLES_FRONT,
ctx, cpu);
total = max(total, runtime_stat_avg(st,
STAT_STALLED_CYCLES_BACK,
ctx, cpu));
if (total && avg) { if (total && avg) {
out->new_line(ctxp); out->new_line(ctxp);
@ -785,8 +831,8 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
"stalled cycles per insn", 0); "stalled cycles per insn", 0);
} }
} else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES)) { } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES)) {
if (runtime_branches_stats[ctx][cpu].n != 0) if (runtime_stat_n(st, STAT_BRANCHES, ctx, cpu) != 0)
print_branch_misses(cpu, evsel, avg, out); print_branch_misses(cpu, evsel, avg, out, st);
else else
print_metric(ctxp, NULL, NULL, "of all branches", 0); print_metric(ctxp, NULL, NULL, "of all branches", 0);
} else if ( } else if (
@ -794,8 +840,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1D | evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1D |
((PERF_COUNT_HW_CACHE_OP_READ) << 8) | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
if (runtime_l1_dcache_stats[ctx][cpu].n != 0)
print_l1_dcache_misses(cpu, evsel, avg, out); if (runtime_stat_n(st, STAT_L1_DCACHE, ctx, cpu) != 0)
print_l1_dcache_misses(cpu, evsel, avg, out, st);
else else
print_metric(ctxp, NULL, NULL, "of all L1-dcache hits", 0); print_metric(ctxp, NULL, NULL, "of all L1-dcache hits", 0);
} else if ( } else if (
@ -803,8 +850,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1I | evsel->attr.config == ( PERF_COUNT_HW_CACHE_L1I |
((PERF_COUNT_HW_CACHE_OP_READ) << 8) | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
if (runtime_l1_icache_stats[ctx][cpu].n != 0)
print_l1_icache_misses(cpu, evsel, avg, out); if (runtime_stat_n(st, STAT_L1_ICACHE, ctx, cpu) != 0)
print_l1_icache_misses(cpu, evsel, avg, out, st);
else else
print_metric(ctxp, NULL, NULL, "of all L1-icache hits", 0); print_metric(ctxp, NULL, NULL, "of all L1-icache hits", 0);
} else if ( } else if (
@ -812,8 +860,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
evsel->attr.config == ( PERF_COUNT_HW_CACHE_DTLB | evsel->attr.config == ( PERF_COUNT_HW_CACHE_DTLB |
((PERF_COUNT_HW_CACHE_OP_READ) << 8) | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
if (runtime_dtlb_cache_stats[ctx][cpu].n != 0)
print_dtlb_cache_misses(cpu, evsel, avg, out); if (runtime_stat_n(st, STAT_DTLB_CACHE, ctx, cpu) != 0)
print_dtlb_cache_misses(cpu, evsel, avg, out, st);
else else
print_metric(ctxp, NULL, NULL, "of all dTLB cache hits", 0); print_metric(ctxp, NULL, NULL, "of all dTLB cache hits", 0);
} else if ( } else if (
@ -821,8 +870,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
evsel->attr.config == ( PERF_COUNT_HW_CACHE_ITLB | evsel->attr.config == ( PERF_COUNT_HW_CACHE_ITLB |
((PERF_COUNT_HW_CACHE_OP_READ) << 8) | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
if (runtime_itlb_cache_stats[ctx][cpu].n != 0)
print_itlb_cache_misses(cpu, evsel, avg, out); if (runtime_stat_n(st, STAT_ITLB_CACHE, ctx, cpu) != 0)
print_itlb_cache_misses(cpu, evsel, avg, out, st);
else else
print_metric(ctxp, NULL, NULL, "of all iTLB cache hits", 0); print_metric(ctxp, NULL, NULL, "of all iTLB cache hits", 0);
} else if ( } else if (
@ -830,27 +880,28 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
evsel->attr.config == ( PERF_COUNT_HW_CACHE_LL | evsel->attr.config == ( PERF_COUNT_HW_CACHE_LL |
((PERF_COUNT_HW_CACHE_OP_READ) << 8) | ((PERF_COUNT_HW_CACHE_OP_READ) << 8) |
((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) { ((PERF_COUNT_HW_CACHE_RESULT_MISS) << 16))) {
if (runtime_ll_cache_stats[ctx][cpu].n != 0)
print_ll_cache_misses(cpu, evsel, avg, out); if (runtime_stat_n(st, STAT_LL_CACHE, ctx, cpu) != 0)
print_ll_cache_misses(cpu, evsel, avg, out, st);
else else
print_metric(ctxp, NULL, NULL, "of all LL-cache hits", 0); print_metric(ctxp, NULL, NULL, "of all LL-cache hits", 0);
} else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES)) { } else if (perf_evsel__match(evsel, HARDWARE, HW_CACHE_MISSES)) {
total = avg_stats(&runtime_cacherefs_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_CACHEREFS, ctx, cpu);
if (total) if (total)
ratio = avg * 100 / total; ratio = avg * 100 / total;
if (runtime_cacherefs_stats[ctx][cpu].n != 0) if (runtime_stat_n(st, STAT_CACHEREFS, ctx, cpu) != 0)
print_metric(ctxp, NULL, "%8.3f %%", print_metric(ctxp, NULL, "%8.3f %%",
"of all cache refs", ratio); "of all cache refs", ratio);
else else
print_metric(ctxp, NULL, NULL, "of all cache refs", 0); print_metric(ctxp, NULL, NULL, "of all cache refs", 0);
} else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) { } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
print_stalled_cycles_frontend(cpu, evsel, avg, out); print_stalled_cycles_frontend(cpu, evsel, avg, out, st);
} else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) { } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_BACKEND)) {
print_stalled_cycles_backend(cpu, evsel, avg, out); print_stalled_cycles_backend(cpu, evsel, avg, out, st);
} else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) { } else if (perf_evsel__match(evsel, HARDWARE, HW_CPU_CYCLES)) {
total = avg_stats(&runtime_nsecs_stats[cpu]); total = runtime_stat_avg(st, STAT_NSECS, 0, cpu);
if (total) { if (total) {
ratio = avg / total; ratio = avg / total;
@ -859,7 +910,8 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
print_metric(ctxp, NULL, NULL, "Ghz", 0); print_metric(ctxp, NULL, NULL, "Ghz", 0);
} }
} else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX)) { } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX)) {
total = avg_stats(&runtime_cycles_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
if (total) if (total)
print_metric(ctxp, NULL, print_metric(ctxp, NULL,
"%7.2f%%", "transactional cycles", "%7.2f%%", "transactional cycles",
@ -868,8 +920,9 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
print_metric(ctxp, NULL, NULL, "transactional cycles", print_metric(ctxp, NULL, NULL, "transactional cycles",
0); 0);
} else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX_CP)) { } else if (perf_stat_evsel__is(evsel, CYCLES_IN_TX_CP)) {
total = avg_stats(&runtime_cycles_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_CYCLES, ctx, cpu);
total2 = avg_stats(&runtime_cycles_in_tx_stats[ctx][cpu]); total2 = runtime_stat_avg(st, STAT_CYCLES_IN_TX, ctx, cpu);
if (total2 < avg) if (total2 < avg)
total2 = avg; total2 = avg;
if (total) if (total)
@ -878,19 +931,21 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
else else
print_metric(ctxp, NULL, NULL, "aborted cycles", 0); print_metric(ctxp, NULL, NULL, "aborted cycles", 0);
} else if (perf_stat_evsel__is(evsel, TRANSACTION_START)) { } else if (perf_stat_evsel__is(evsel, TRANSACTION_START)) {
total = avg_stats(&runtime_cycles_in_tx_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_CYCLES_IN_TX,
ctx, cpu);
if (avg) if (avg)
ratio = total / avg; ratio = total / avg;
if (runtime_cycles_in_tx_stats[ctx][cpu].n != 0) if (runtime_stat_n(st, STAT_CYCLES_IN_TX, ctx, cpu) != 0)
print_metric(ctxp, NULL, "%8.0f", print_metric(ctxp, NULL, "%8.0f",
"cycles / transaction", ratio); "cycles / transaction", ratio);
else else
print_metric(ctxp, NULL, NULL, "cycles / transaction", print_metric(ctxp, NULL, NULL, "cycles / transaction",
0); 0);
} else if (perf_stat_evsel__is(evsel, ELISION_START)) { } else if (perf_stat_evsel__is(evsel, ELISION_START)) {
total = avg_stats(&runtime_cycles_in_tx_stats[ctx][cpu]); total = runtime_stat_avg(st, STAT_CYCLES_IN_TX,
ctx, cpu);
if (avg) if (avg)
ratio = total / avg; ratio = total / avg;
@ -904,28 +959,28 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
else else
print_metric(ctxp, NULL, NULL, "CPUs utilized", 0); print_metric(ctxp, NULL, NULL, "CPUs utilized", 0);
} else if (perf_stat_evsel__is(evsel, TOPDOWN_FETCH_BUBBLES)) { } else if (perf_stat_evsel__is(evsel, TOPDOWN_FETCH_BUBBLES)) {
double fe_bound = td_fe_bound(ctx, cpu); double fe_bound = td_fe_bound(ctx, cpu, st);
if (fe_bound > 0.2) if (fe_bound > 0.2)
color = PERF_COLOR_RED; color = PERF_COLOR_RED;
print_metric(ctxp, color, "%8.1f%%", "frontend bound", print_metric(ctxp, color, "%8.1f%%", "frontend bound",
fe_bound * 100.); fe_bound * 100.);
} else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_RETIRED)) { } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_RETIRED)) {
double retiring = td_retiring(ctx, cpu); double retiring = td_retiring(ctx, cpu, st);
if (retiring > 0.7) if (retiring > 0.7)
color = PERF_COLOR_GREEN; color = PERF_COLOR_GREEN;
print_metric(ctxp, color, "%8.1f%%", "retiring", print_metric(ctxp, color, "%8.1f%%", "retiring",
retiring * 100.); retiring * 100.);
} else if (perf_stat_evsel__is(evsel, TOPDOWN_RECOVERY_BUBBLES)) { } else if (perf_stat_evsel__is(evsel, TOPDOWN_RECOVERY_BUBBLES)) {
double bad_spec = td_bad_spec(ctx, cpu); double bad_spec = td_bad_spec(ctx, cpu, st);
if (bad_spec > 0.1) if (bad_spec > 0.1)
color = PERF_COLOR_RED; color = PERF_COLOR_RED;
print_metric(ctxp, color, "%8.1f%%", "bad speculation", print_metric(ctxp, color, "%8.1f%%", "bad speculation",
bad_spec * 100.); bad_spec * 100.);
} else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_ISSUED)) { } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_ISSUED)) {
double be_bound = td_be_bound(ctx, cpu); double be_bound = td_be_bound(ctx, cpu, st);
const char *name = "backend bound"; const char *name = "backend bound";
static int have_recovery_bubbles = -1; static int have_recovery_bubbles = -1;
@ -938,19 +993,19 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
if (be_bound > 0.2) if (be_bound > 0.2)
color = PERF_COLOR_RED; color = PERF_COLOR_RED;
if (td_total_slots(ctx, cpu) > 0) if (td_total_slots(ctx, cpu, st) > 0)
print_metric(ctxp, color, "%8.1f%%", name, print_metric(ctxp, color, "%8.1f%%", name,
be_bound * 100.); be_bound * 100.);
else else
print_metric(ctxp, NULL, NULL, name, 0); print_metric(ctxp, NULL, NULL, name, 0);
} else if (evsel->metric_expr) { } else if (evsel->metric_expr) {
generic_metric(evsel->metric_expr, evsel->metric_events, evsel->name, generic_metric(evsel->metric_expr, evsel->metric_events, evsel->name,
evsel->metric_name, avg, cpu, out); evsel->metric_name, avg, cpu, out, st);
} else if (runtime_nsecs_stats[cpu].n != 0) { } else if (runtime_stat_n(st, STAT_NSECS, 0, cpu) != 0) {
char unit = 'M'; char unit = 'M';
char unit_buf[10]; char unit_buf[10];
total = avg_stats(&runtime_nsecs_stats[cpu]); total = runtime_stat_avg(st, STAT_NSECS, 0, cpu);
if (total) if (total)
ratio = 1000.0 * avg / total; ratio = 1000.0 * avg / total;
@ -961,7 +1016,7 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
snprintf(unit_buf, sizeof(unit_buf), "%c/sec", unit); snprintf(unit_buf, sizeof(unit_buf), "%c/sec", unit);
print_metric(ctxp, NULL, "%8.3f", unit_buf, ratio); print_metric(ctxp, NULL, "%8.3f", unit_buf, ratio);
} else if (perf_stat_evsel__is(evsel, SMI_NUM)) { } else if (perf_stat_evsel__is(evsel, SMI_NUM)) {
print_smi_cost(cpu, evsel, out); print_smi_cost(cpu, evsel, out, st);
} else { } else {
num = 0; num = 0;
} }
@ -974,7 +1029,7 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
out->new_line(ctxp); out->new_line(ctxp);
generic_metric(mexp->metric_expr, mexp->metric_events, generic_metric(mexp->metric_expr, mexp->metric_events,
evsel->name, mexp->metric_name, evsel->name, mexp->metric_name,
avg, cpu, out); avg, cpu, out, st);
} }
} }
if (num == 0) if (num == 0)

3
tools/perf/util/stat.h
View file

@ -140,7 +140,8 @@ struct perf_stat_output_ctx {
void perf_stat__print_shadow_stats(struct perf_evsel *evsel, void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
double avg, int cpu, double avg, int cpu,
struct perf_stat_output_ctx *out, struct perf_stat_output_ctx *out,
struct rblist *metric_events); struct rblist *metric_events,
struct runtime_stat *st);
void perf_stat__collect_metric_expr(struct perf_evlist *); void perf_stat__collect_metric_expr(struct perf_evlist *);
int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw); int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw);