From c4291c1524ee4e4575c3b0a726ca5507b2ba74f3 Mon Sep 17 00:00:00 2001
From: Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl>
Date: Sun, 18 Oct 2015 17:10:51 -0400
Subject: test-compress-benchmark: limit default runtime to 2 seconds per
 subtest
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If both lz4 and xz are enabled, this results in a limit of
2×3×2 s ~= 12 s runtime.

Previous implementation started with really small buffer sizes. When
combined with a short time limit this resulteded in abysmal results for xz.
It seems that the initialization overead is really significant for small
buffers. Since xz will not be used by default anymore, this does not
seem worth fixing. Instead buffer sizes are changed to run a
pseudo-random non-repeating pattern. This should allow reasonable testing
for all buffer sizes. For testing, both runtime and the buffer size seed
can be specified on the command line. Sufficiently large runtime allows
all buffer sizes up to 1MB to be tested.
---
 src/journal/test-compress-benchmark.c | 66 ++++++++++++++++++++++++++++-------
 1 file changed, 53 insertions(+), 13 deletions(-)

diff --git a/src/journal/test-compress-benchmark.c b/src/journal/test-compress-benchmark.c
index 0be6820a14..385c85e5b9 100644
--- a/src/journal/test-compress-benchmark.c
+++ b/src/journal/test-compress-benchmark.c
@@ -1,3 +1,5 @@
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
+
 /***
   This file is part of systemd
 
@@ -26,7 +28,28 @@ typedef int (compress_t)(const void *src, uint64_t src_size, void *dst, size_t *
 typedef int (decompress_t)(const void *src, uint64_t src_size,
                            void **dst, size_t *dst_alloc_size, size_t* dst_size, size_t dst_max);
 
+static usec_t arg_duration = 2 * USEC_PER_SEC;
+static size_t arg_start;
+
 #define MAX_SIZE (1024*1024LU)
+#define PRIME 1048571  /* A prime close enough to one megabyte that mod 4 == 3 */
+
+static size_t _permute(size_t x) {
+        size_t residue;
+
+        if (x >= PRIME)
+                return x;
+
+        residue = x*x % PRIME;
+        if (x <= PRIME / 2)
+                return residue;
+        else
+                return PRIME - residue;
+}
+
+static size_t permute(size_t x) {
+        return _permute((_permute(x) + arg_start) % MAX_SIZE ^ 0xFF345);
+}
 
 static char* make_buf(size_t count, const char *type) {
         char *buf;
@@ -68,37 +91,43 @@ static void test_compress_decompress(const char* label, const char* type,
 
         n = now(CLOCK_MONOTONIC);
 
-        for (size_t i = 1; i <= MAX_SIZE; i += (i < 2048 ? 1 : 217)) {
-                size_t j = 0, k = 0;
+        for (size_t i = 0; i <= MAX_SIZE; i++) {
+                size_t j = 0, k = 0, size;
                 int r;
 
-                r = compress(text, i, buf, &j);
+                size = permute(i);
+
+                log_debug("%s %zu %zu", type, i, size);
+
+                memzero(buf, MIN(size + 1000, MAX_SIZE));
+
+                r = compress(text, size, buf, &j);
                 /* assume compression must be successful except for small inputs */
-                assert_se(r == 0 || (i < 2048 && r == -ENOBUFS) || streq(type, "random"));
+                assert_se(r == 0 || (size < 2048 && r == -ENOBUFS) || streq(type, "random"));
 
                 /* check for overwrites */
-                assert_se(buf[i] == 0);
+                assert_se(buf[size] == 0);
                 if (r != 0) {
-                        skipped += i;
+                        skipped += size;
                         continue;
                 }
 
                 assert_se(j > 0);
-                if (j >= i)
-                        log_error("%s \"compressed\" %zu -> %zu", label, i, j);
+                if (j >= size)
+                        log_error("%s \"compressed\" %zu -> %zu", label, size, j);
 
                 r = decompress(buf, j, &buf2, &buf2_allocated, &k, 0);
                 assert_se(r == 0);
                 assert_se(buf2_allocated >= k);
-                assert_se(k == i);
+                assert_se(k == size);
 
-                assert_se(memcmp(text, buf2, i) == 0);
+                assert_se(memcmp(text, buf2, size) == 0);
 
-                total += i;
+                total += size;
                 compressed += j;
 
                 n2 = now(CLOCK_MONOTONIC);
-                if (n2 - n > 60 * USEC_PER_SEC)
+                if (n2 - n > arg_duration)
                         break;
         }
 
@@ -115,7 +144,18 @@ static void test_compress_decompress(const char* label, const char* type,
 int main(int argc, char *argv[]) {
         const char *i;
 
-        log_set_max_level(LOG_DEBUG);
+        log_set_max_level(LOG_INFO);
+
+        if (argc >= 2) {
+                unsigned x;
+
+                assert_se(safe_atou(argv[1], &x) >= 0);
+                arg_duration = x * USEC_PER_SEC;
+        }
+        if (argc == 3)
+                (void) safe_atolu(argv[2], &arg_start);
+        else
+                arg_start = getpid();
 
         NULSTR_FOREACH(i, "zeros\0simple\0random\0") {
 #ifdef HAVE_XZ
-- 
cgit v1.2.3-54-g00ecf