lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

perf stat: Change noise calculation to use stddev

Browse Source 
The current noise computation does:

 \Sum abs(n_i - avg(n)) * N^-1.5

Which is (afaik) not a regular noise function, and needs the
complete sample set available to post-process.

Change this to use a regular stddev computation which can be
done by keeping a two sums:

 stddev = sqrt( 1/N (\Sum n_i^2) - avg(n)^2 )

For which we only need to keep \Sum n_i and \Sum n_i^2.

Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: <stable@kernel.org>
LKML-Reference: <new-submission>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Peter Zijlstra
2009-09-04 15:36:12 +02:00
committed by Ingo Molnar
parent 1653192f51
commit 506d4bc8d5
1 changed files with 69 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
tools/perf/builtin-stat.c
View File

@@ -83,19 +83,32 @@ static u64 runtime_cycles[MAX_RUN];
static u64 event_res[MAX_RUN][MAX_COUNTERS][3]; static u64 event_res[MAX_RUN][MAX_COUNTERS][3];
static u64 event_scaled[MAX_RUN][MAX_COUNTERS]; static u64 event_scaled[MAX_RUN][MAX_COUNTERS];
static u64 event_res_avg[MAX_COUNTERS][3]; struct stats
static u64 event_res_noise[MAX_COUNTERS][3]; {
double sum;
double sum_sq;
};
static u64 event_scaled_avg[MAX_COUNTERS]; static double avg_stats(struct stats *stats)
{
return stats->sum / run_count;
}
static u64 runtime_nsecs_avg; /*
static u64 runtime_nsecs_noise; * stddev = sqrt(1/N (\Sum n_i^2) - avg(n)^2)
*/
static double stddev_stats(struct stats *stats)
{
double avg = stats->sum / run_count;
static u64 walltime_nsecs_avg; return sqrt(stats->sum_sq/run_count - avg*avg);
static u64 walltime_nsecs_noise; }
static u64 runtime_cycles_avg; struct stats event_res_stats[MAX_COUNTERS][3];
static u64 runtime_cycles_noise; struct stats event_scaled_stats[MAX_COUNTERS];
struct stats runtime_nsecs_stats;
struct stats walltime_nsecs_stats;
struct stats runtime_cycles_stats;
#define MATCH_EVENT(t, c, counter) \ #define MATCH_EVENT(t, c, counter) \
(attrs[counter].type == PERF_TYPE_##t && \ (attrs[counter].type == PERF_TYPE_##t && \
@@ -279,42 +292,37 @@ static int run_perf_stat(int argc __used, const char **argv)
return WEXITSTATUS(status); return WEXITSTATUS(status);
} }
static void print_noise(u64 *count, u64 *noise) static void print_noise(double avg, double stddev)
{ {
if (run_count > 1) if (run_count > 1)
fprintf(stderr, " ( +- %7.3f%% )", fprintf(stderr, " ( +- %7.3f%% )", 100*stddev / avg);
(double)noise[0]/(count[0]+1)*100.0);
} }
static void nsec_printout(int counter, u64 *count, u64 *noise) static void nsec_printout(int counter, double avg, double stddev)
{ {
double msecs = (double)count[0] / 1000000; double msecs = avg / 1e6;
fprintf(stderr, " %14.6f %-24s", msecs, event_name(counter)); fprintf(stderr, " %14.6f %-24s", msecs, event_name(counter));
if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) { if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
if (walltime_nsecs_avg) fprintf(stderr, " # %10.3f CPUs ",
fprintf(stderr, " # %10.3f CPUs ", avg / avg_stats(&walltime_nsecs_stats));
(double)count[0] / (double)walltime_nsecs_avg);
} }
print_noise(count, noise); print_noise(avg, stddev);
} }
static void abs_printout(int counter, u64 *count, u64 *noise) static void abs_printout(int counter, double avg, double stddev)
{ {
fprintf(stderr, " %14Ld %-24s", count[0], event_name(counter)); fprintf(stderr, " %14.0f %-24s", avg, event_name(counter));
if (runtime_cycles_avg && if (MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
fprintf(stderr, " # %10.3f IPC ", fprintf(stderr, " # %10.3f IPC ",
(double)count[0] / (double)runtime_cycles_avg); avg / avg_stats(&runtime_cycles_stats));
} else { } else {
if (runtime_nsecs_avg) { fprintf(stderr, " # %10.3f M/sec",
fprintf(stderr, " # %10.3f M/sec", 1000.0 * avg / avg_stats(&runtime_nsecs_stats));
(double)count[0]/runtime_nsecs_avg*1000.0);
}
} }
print_noise(count, noise); print_noise(avg, stddev);
} }
/* /*
@@ -322,12 +330,12 @@ static void abs_printout(int counter, u64 *count, u64 *noise)
*/ */
static void print_counter(int counter) static void print_counter(int counter)
{ {
u64 *count, *noise; double avg, stddev;
int scaled; int scaled;
count = event_res_avg[counter]; avg = avg_stats(&event_res_stats[counter][0]);
noise = event_res_noise[counter]; stddev = stddev_stats(&event_res_stats[counter][0]);
scaled = event_scaled_avg[counter]; scaled = avg_stats(&event_scaled_stats[counter]);
if (scaled == -1) { if (scaled == -1) {
fprintf(stderr, " %14s %-24s\n", fprintf(stderr, " %14s %-24s\n",
@@ -336,36 +344,34 @@ static void print_counter(int counter)
} }
if (nsec_counter(counter)) if (nsec_counter(counter))
nsec_printout(counter, count, noise); nsec_printout(counter, avg, stddev);
else else
abs_printout(counter, count, noise); abs_printout(counter, avg, stddev);
if (scaled) {
double avg_enabled, avg_running;
avg_enabled = avg_stats(&event_res_stats[counter][1]);
avg_running = avg_stats(&event_res_stats[counter][2]);
if (scaled)
fprintf(stderr, " (scaled from %.2f%%)", fprintf(stderr, " (scaled from %.2f%%)",
(double) count[2] / count[1] * 100); 100 * avg_running / avg_enabled);
}
fprintf(stderr, "\n"); fprintf(stderr, "\n");
} }
/* static void update_stats(const char *name, int idx, struct stats *stats, u64 *val)
* normalize_noise noise values down to stddev:
*/
static void normalize_noise(u64 *val)
{ {
double res; double sq = *val;
res = (double)*val / (run_count * sqrt((double)run_count)); stats->sum += *val;
stats->sum_sq += sq * sq;
*val = (u64)res;
}
static void update_avg(const char *name, int idx, u64 *avg, u64 *val)
{
*avg += *val;
if (verbose > 1) if (verbose > 1)
fprintf(stderr, "debug: %20s[%d]: %Ld\n", name, idx, *val); fprintf(stderr, "debug: %20s[%d]: %Ld\n", name, idx, *val);
} }
/* /*
* Calculate the averages and noises: * Calculate the averages and noises:
*/ */
@@ -377,61 +383,22 @@ static void calc_avg(void)
fprintf(stderr, "\n"); fprintf(stderr, "\n");
for (i = 0; i < run_count; i++) { for (i = 0; i < run_count; i++) {
update_avg("runtime", 0, &runtime_nsecs_avg, runtime_nsecs + i); update_stats("runtime", 0, &runtime_nsecs_stats, runtime_nsecs + i);
update_avg("walltime", 0, &walltime_nsecs_avg, walltime_nsecs + i); update_stats("walltime", 0, &walltime_nsecs_stats, walltime_nsecs + i);
update_avg("runtime_cycles", 0, &runtime_cycles_avg, runtime_cycles + i); update_stats("runtime_cycles", 0, &runtime_cycles_stats, runtime_cycles + i);
for (j = 0; j < nr_counters; j++) { for (j = 0; j < nr_counters; j++) {
update_avg("counter/0", j, update_stats("counter/0", j,
event_res_avg[j]+0, event_res[i][j]+0); event_res_stats[j]+0, event_res[i][j]+0);
update_avg("counter/1", j, update_stats("counter/1", j,
event_res_avg[j]+1, event_res[i][j]+1); event_res_stats[j]+1, event_res[i][j]+1);
update_avg("counter/2", j, update_stats("counter/2", j,
event_res_avg[j]+2, event_res[i][j]+2); event_res_stats[j]+2, event_res[i][j]+2);
if (event_scaled[i][j] != (u64)-1) if (event_scaled[i][j] != (u64)-1)
update_avg("scaled", j, update_stats("scaled", j,
event_scaled_avg + j, event_scaled[i]+j); event_scaled_stats + j, event_scaled[i]+j);
else
event_scaled_avg[j] = -1;
} }
} }
runtime_nsecs_avg /= run_count;
walltime_nsecs_avg /= run_count;
runtime_cycles_avg /= run_count;
for (j = 0; j < nr_counters; j++) {
event_res_avg[j][0] /= run_count;
event_res_avg[j][1] /= run_count;
event_res_avg[j][2] /= run_count;
}
for (i = 0; i < run_count; i++) {
runtime_nsecs_noise +=
abs((s64)(runtime_nsecs[i] - runtime_nsecs_avg));
walltime_nsecs_noise +=
abs((s64)(walltime_nsecs[i] - walltime_nsecs_avg));
runtime_cycles_noise +=
abs((s64)(runtime_cycles[i] - runtime_cycles_avg));
for (j = 0; j < nr_counters; j++) {
event_res_noise[j][0] +=
abs((s64)(event_res[i][j][0] - event_res_avg[j][0]));
event_res_noise[j][1] +=
abs((s64)(event_res[i][j][1] - event_res_avg[j][1]));
event_res_noise[j][2] +=
abs((s64)(event_res[i][j][2] - event_res_avg[j][2]));
}
}
normalize_noise(&runtime_nsecs_noise);
normalize_noise(&walltime_nsecs_noise);
normalize_noise(&runtime_cycles_noise);
for (j = 0; j < nr_counters; j++) {
normalize_noise(&event_res_noise[j][0]);
normalize_noise(&event_res_noise[j][1]);
normalize_noise(&event_res_noise[j][2]);
}
} }
static void print_stat(int argc, const char **argv) static void print_stat(int argc, const char **argv)
@@ -458,10 +425,11 @@ static void print_stat(int argc, const char **argv)
fprintf(stderr, "\n"); fprintf(stderr, "\n");
fprintf(stderr, " %14.9f seconds time elapsed", fprintf(stderr, " %14.9f seconds time elapsed",
(double)walltime_nsecs_avg/1e9); avg_stats(&walltime_nsecs_stats)/1e9);
if (run_count > 1) { if (run_count > 1) {
fprintf(stderr, " ( +- %7.3f%% )", fprintf(stderr, " ( +- %7.3f%% )",
100.0*(double)walltime_nsecs_noise/(double)walltime_nsecs_avg); 100*stddev_stats(&walltime_nsecs_stats) /
avg_stats(&walltime_nsecs_stats));
} }
fprintf(stderr, "\n\n"); fprintf(stderr, "\n\n");
} }