po: Incorporate translations (sr)

[thirdparty/glibc.git] / benchtests / bench-skeleton.c

diff --git a/benchtests/bench-skeleton.c b/benchtests/bench-skeleton.c
index bc820dff7e66ddac6832d4333a791686164c2303..60add3f3f3c367c4e2d450e62b24437f43ea532a 100644 (file)
--- a/benchtests/bench-skeleton.c
+++ b/benchtests/bench-skeleton.c
@@ -1,5 +1,5 @@
 /* Skeleton for benchmark programs.
-   Copyright (C) 2013-2015 Free Software Foundation, Inc.
+   Copyright (C) 2013-2024 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -14,7 +14,7 @@
 
    You should have received a copy of the GNU Lesser General Public
    License along with the GNU C Library; if not, see
-   <http://www.gnu.org/licenses/>.  */
+   <https://www.gnu.org/licenses/>.  */
 
 #include <string.h>
 #include <stdint.h>
@@ -29,9 +29,9 @@
 #include "bench-util.c"
 
 #define TIMESPEC_AFTER(a, b) \
-  (((a).tv_sec == (b).tv_sec) ?                                                      \
-     ((a).tv_nsec > (b).tv_nsec) :                                           \
-       ((a).tv_sec > (b).tv_sec))
+  (((a).tv_sec == (b).tv_sec)                                                \
+   ? ((a).tv_nsec > (b).tv_nsec)                                             \
+   : ((a).tv_sec > (b).tv_sec))
 int
 main (int argc, char **argv)
 {
@@ -48,14 +48,11 @@ main (int argc, char **argv)
 
   memset (&runtime, 0, sizeof (runtime));
 
-  unsigned long iters, res;
+  unsigned long iters = 2000;
 
 #ifdef BENCH_INIT
   BENCH_INIT ();
 #endif
-  TIMING_INIT (res);
-
-  iters = 1000 * res;
 
   json_init (&json_ctx, 2, stdout);
 
@@ -68,34 +65,61 @@ 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;
+      timing_t throughput = 0, latency = 0;
       int64_t c = 0;
+      uint64_t cur;
+      BENCH_VARS;
       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);
+             TIMING_ACCUM (throughput, cur);
 
+             TIMING_NOW (start);
+             for (k = 0; k < iters; k++)
+               for (i = 0; i < NUM_SAMPLES (v); i++)
+                 BENCH_FUNC_LAT (v, i);
+             TIMING_NOW (end);
              TIMING_DIFF (cur, start, end);
+             TIMING_ACCUM (latency, cur);
 
-             if (cur > max)
-               max = cur;
+             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);
 
-             if (cur < min)
-               min = cur;
+               TIMING_DIFF (cur, start, end);
 
-             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);
+               if (cur > max)
+                 max = cur;
 
-             d_total_i += iters;
-           }
+               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;
 
@@ -115,13 +139,28 @@ main (int argc, char **argv)
       /* Begin variant.  */
       json_attr_object_begin (&json_ctx, VARIANT (v));
 
-      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, "duration", throughput + latency);
+         json_attr_double (&json_ctx, "iterations", 2 * d_total_i);
+         json_attr_double (&json_ctx, "reciprocal-throughput",
+                           throughput / d_total_i);
+         json_attr_double (&json_ctx, "latency", latency / d_total_i);
+         json_attr_double (&json_ctx, "max-throughput",
+                           d_total_i / throughput * 1000000000.0);
+         json_attr_double (&json_ctx, "min-throughput",
+                           d_total_i / latency * 1000000000.0);
+       }
+      else
+       {
+         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 (detailed)
+      if (detailed && !is_bench)
        {
          json_array_begin (&json_ctx, "timings");