AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-22 19:00:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Improve math benchmark infrastructure

Browse Source 
Improve support for math function benchmarking.  This patch adds
a feature that allows accurate benchmarking of traces extracted
from real workloads.  This is done by iterating over all samples
rather than repeating each sample many times (which completely
ignores branch prediction and cache effects).  A trace can be
added to existing math function inputs via
"## name: workload-<name>", followed by the trace.

        * benchtests/README: Describe workload feature.
        * benchtests/bench-skeleton.c (main): Add support for
        benchmarking traces from workloads.
This commit is contained in:
Wilco Dijkstra 2017-06-20 16:26:26 +01:00
parent c0b23001a8
commit beb52f502f
3 changed files with 53 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,3 +1,9 @@
2017-06-20 Wilco Dijkstra <wdijkstr@arm.com>
* benchtests/README: Describe workload feature.
* benchtests/bench-skeleton.c (main): Add support for
benchmarking traces from workloads.
2017-06-20 Zack Weinberg <zackw@panix.com>
* string/string.h (__mempcpy_inline): Delete.

6
benchtests/README
View File

@ -102,6 +102,12 @@ the same file by using the `name' directive that looks something like this:
See the pow-inputs file for an example of what such a partitioned input file
would look like.
It is also possible to measure throughput of a (partial) trace extracted from
a real workload. In this case the whole trace is iterated over multiple times
rather than repeating every input multiple times. This can be done via:
##name: workload-<name>
Benchmark Sets:
==============

61
benchtests/bench-skeleton.c
View File

@ -68,34 +68,50 @@ main (int argc, char **argv)
clock_gettime (CLOCK_MONOTONIC_RAW, &runtime);
runtime.tv_sec += DURATION;
bool is_bench = strncmp (VARIANT (v), "workload-", 9) == 0;
double d_total_i = 0;
timing_t total = 0, max = 0, min = 0x7fffffffffffffff;
int64_t c = 0;
uint64_t cur;
while (1)
{
for (i = 0; i < NUM_SAMPLES (v); i++)
if (is_bench)
{
uint64_t cur;
/* Benchmark a real trace of calls - all samples are iterated
over once before repeating. This models actual use more
accurately than repeating the same sample many times. */
TIMING_NOW (start);
for (k = 0; k < iters; k++)
BENCH_FUNC (v, i);
for (i = 0; i < NUM_SAMPLES (v); i++)
BENCH_FUNC (v, i);
TIMING_NOW (end);
TIMING_DIFF (cur, start, end);
if (cur > max)
max = cur;
if (cur < min)
min = cur;
TIMING_ACCUM (total, cur);
/* Accumulate timings for the value. In the end we will divide
by the total iterations. */
RESULT_ACCUM (cur, v, i, c * iters, (c + 1) * iters);
d_total_i += iters;
d_total_i += iters * NUM_SAMPLES (v);
}
else
for (i = 0; i < NUM_SAMPLES (v); i++)
{
TIMING_NOW (start);
for (k = 0; k < iters; k++)
BENCH_FUNC (v, i);
TIMING_NOW (end);
TIMING_DIFF (cur, start, end);
if (cur > max)
max = cur;
if (cur < min)
min = cur;
TIMING_ACCUM (total, cur);
/* Accumulate timings for the value. In the end we will divide
by the total iterations. */
RESULT_ACCUM (cur, v, i, c * iters, (c + 1) * iters);
d_total_i += iters;
}
c++;
struct timespec curtime;
@ -117,11 +133,16 @@ main (int argc, char **argv)
json_attr_double (&json_ctx, "duration", d_total_s);
json_attr_double (&json_ctx, "iterations", d_total_i);
json_attr_double (&json_ctx, "max", max / d_iters);
json_attr_double (&json_ctx, "min", min / d_iters);
json_attr_double (&json_ctx, "mean", d_total_s / d_total_i);
if (is_bench)
json_attr_double (&json_ctx, "throughput", d_total_s / d_total_i);
else
{
json_attr_double (&json_ctx, "max", max / d_iters);
json_attr_double (&json_ctx, "min", min / d_iters);
json_attr_double (&json_ctx, "mean", d_total_s / d_total_i);
}
if (detailed)
if (detailed && !is_bench)
{
json_array_begin (&json_ctx, "timings");