Add wrapper for Alexey Kopytov's sysbench, memory benchmarks

Signed-off-by: Burt P <pburt0@gmail.com>

4 files changed, 167 insertions, 2 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 309614f7..d5f140a2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -186,6 +186,7 @@ set(MODULE_benchmark_SOURCES_GTKANY
 	modules/benchmark/raytrace.c
 	modules/benchmark/sha1.c
 	modules/benchmark/zlib.c
+	modules/benchmark/sysbench.c
 )
 set(MODULE_benchmark_SOURCES_GTK2
 	modules/benchmark/drawing.c
diff --git a/includes/benchmark.h b/includes/benchmark.h
index 8af3739b..02c40c4a 100644
--- a/includes/benchmark.h
+++ b/includes/benchmark.h
@@ -10,12 +10,15 @@ enum {
     BENCHMARK_BLOWFISH_SINGLE,
     BENCHMARK_BLOWFISH_THREADS,
     BENCHMARK_BLOWFISH_CORES,
+    BENCHMARK_ZLIB,
     BENCHMARK_CRYPTOHASH,
     BENCHMARK_FIB,
     BENCHMARK_NQUEENS,
-    BENCHMARK_ZLIB,
     BENCHMARK_FFT,
     BENCHMARK_RAYTRACE,
+    BENCHMARK_MEMORY_SINGLE,
+    BENCHMARK_MEMORY_DUAL,
+    BENCHMARK_MEMORY_QUAD,
     BENCHMARK_GUI,
     BENCHMARK_N_ENTRIES
 } BenchmarkEntries;
@@ -23,6 +26,9 @@ enum {
 void benchmark_bfish_single(void);
 void benchmark_bfish_threads(void);
 void benchmark_bfish_cores(void);
+void benchmark_memory_single(void);
+void benchmark_memory_dual(void);
+void benchmark_memory_quad(void);
 void benchmark_cryptohash(void);
 void benchmark_fft(void);
 void benchmark_fib(void);
diff --git a/modules/benchmark/benches.c b/modules/benchmark/benches.c
index 354757c1..5b5fc4d5 100644
--- a/modules/benchmark/benches.c
+++ b/modules/benchmark/benches.c
@@ -35,6 +35,9 @@ BENCH_CALLBACK(callback_raytr, "FPU Raytracing", BENCHMARK_RAYTRACE, 0);
 BENCH_CALLBACK(callback_bfsh_single, "CPU Blowfish (Single-thread)", BENCHMARK_BLOWFISH_SINGLE, 1);
 BENCH_CALLBACK(callback_bfsh_threads, "CPU Blowfish (Multi-thread)", BENCHMARK_BLOWFISH_THREADS, 1);
 BENCH_CALLBACK(callback_bfsh_cores, "CPU Blowfish (Multi-core)", BENCHMARK_BLOWFISH_CORES, 1);
+BENCH_CALLBACK(callback_memory_single, "Memory (Single)", BENCHMARK_MEMORY_SINGLE, 1);
+BENCH_CALLBACK(callback_memory_dual, "Memory (Double)", BENCHMARK_MEMORY_DUAL, 1);
+BENCH_CALLBACK(callback_memory_quad, "Memory (Quad)", BENCHMARK_MEMORY_QUAD, 1);
 BENCH_CALLBACK(callback_cryptohash, "CPU CryptoHash", BENCHMARK_CRYPTOHASH, 1);
 BENCH_CALLBACK(callback_zlib, "CPU Zlib", BENCHMARK_ZLIB, 1);
 BENCH_CALLBACK(callback_gui, "GPU Drawing", BENCHMARK_GUI, 1);
@@ -52,6 +55,9 @@ BENCH_SCAN_SIMPLE(scan_raytr, benchmark_raytrace, BENCHMARK_RAYTRACE);
 BENCH_SCAN_SIMPLE(scan_bfsh_single, benchmark_bfish_single, BENCHMARK_BLOWFISH_SINGLE);
 BENCH_SCAN_SIMPLE(scan_bfsh_threads, benchmark_bfish_threads, BENCHMARK_BLOWFISH_THREADS);
 BENCH_SCAN_SIMPLE(scan_bfsh_cores, benchmark_bfish_cores, BENCHMARK_BLOWFISH_CORES);
+BENCH_SCAN_SIMPLE(scan_memory_single, benchmark_memory_single, BENCHMARK_MEMORY_SINGLE);
+BENCH_SCAN_SIMPLE(scan_memory_dual, benchmark_memory_dual, BENCHMARK_MEMORY_DUAL);
+BENCH_SCAN_SIMPLE(scan_memory_quad, benchmark_memory_quad, BENCHMARK_MEMORY_QUAD);
 BENCH_SCAN_SIMPLE(scan_cryptohash, benchmark_cryptohash, BENCHMARK_CRYPTOHASH);
 BENCH_SCAN_SIMPLE(scan_fib, benchmark_fib, BENCHMARK_FIB);
 BENCH_SCAN_SIMPLE(scan_zlib, benchmark_zlib, BENCHMARK_ZLIB);
@@ -82,12 +88,15 @@ static ModuleEntry entries[] = {
     {N_("CPU Blowfish (Single-thread)"), "blowfish.png", callback_bfsh_single, scan_bfsh_single, MODULE_FLAG_NONE},
     {N_("CPU Blowfish (Multi-thread)"), "blowfish.png", callback_bfsh_threads, scan_bfsh_threads, MODULE_FLAG_NONE},
     {N_("CPU Blowfish (Multi-core)"), "blowfish.png", callback_bfsh_cores, scan_bfsh_cores, MODULE_FLAG_NONE},
+    {N_("CPU Zlib"), "file-roller.png", callback_zlib, scan_zlib, MODULE_FLAG_NONE},
     {N_("CPU CryptoHash"), "cryptohash.png", callback_cryptohash, scan_cryptohash, MODULE_FLAG_NONE},
     {N_("CPU Fibonacci"), "nautilus.png", callback_fib, scan_fib, MODULE_FLAG_NONE},
     {N_("CPU N-Queens"), "nqueens.png", callback_nqueens, scan_nqueens, MODULE_FLAG_NONE},
-    {N_("CPU Zlib"), "file-roller.png", callback_zlib, scan_zlib, MODULE_FLAG_NONE},
     {N_("FPU FFT"), "fft.png", callback_fft, scan_fft, MODULE_FLAG_NONE},
     {N_("FPU Raytracing"), "raytrace.png", callback_raytr, scan_raytr, MODULE_FLAG_NONE},
+    {N_("SysBench Memory (Single-thread)"), "memory.png", callback_memory_single, scan_memory_single, MODULE_FLAG_NONE},
+    {N_("SysBench Memory (Two threads)"), "memory.png", callback_memory_dual, scan_memory_dual, MODULE_FLAG_NONE},
+    {N_("SysBench Memory (Four threads)"), "memory.png", callback_memory_quad, scan_memory_quad, MODULE_FLAG_NONE},
 #if !GTK_CHECK_VERSION(3,0,0)
     {N_("GPU Drawing"), "module.png", callback_gui, scan_gui, MODULE_FLAG_NO_REMOTE},
 #endif
@@ -97,6 +106,12 @@ static ModuleEntry entries[] = {
 const gchar *hi_note_func(gint entry)
 {
     switch (entry) {
+    case BENCHMARK_MEMORY_SINGLE:
+    case BENCHMARK_MEMORY_DUAL:
+    case BENCHMARK_MEMORY_QUAD:
+        return _("Alexey Kopytov's <i><b>sysbench</b></i> is required.\n"
+                 "Results in MiB/second. Higher is better.");
+
     case BENCHMARK_CRYPTOHASH:
         return _("Results in MiB/second. Higher is better.");
 
diff --git a/modules/benchmark/sysbench.c b/modules/benchmark/sysbench.c
new file mode 100644
index 00000000..479144ba
--- /dev/null
+++ b/modules/benchmark/sysbench.c
@@ -0,0 +1,143 @@
+/*
+ *    HardInfo - Displays System Information
+ *    Copyright (C) 2003-2017 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *    Copyright (C) 2019 Burt P. <pburt0@gmail.com>
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation, version 2.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+
+#include "hardinfo.h"
+#include "benchmark.h"
+
+struct sysbench_ctx {
+    char *test;
+    char *parms;
+    bench_value r;
+};
+
+static gboolean sysbench_run(struct sysbench_ctx *ctx) {
+    gboolean spawned;
+    gchar *out, *err, *p, *next_nl;
+
+    int v1 = 0, v2 = 0, v3 = 0, mc = 0;
+    char *pp = NULL;
+
+    if (!ctx) return FALSE;
+    if (!ctx->test) return FALSE;
+    if (!ctx->parms) return FALSE;
+    snprintf(ctx->r.extra, 255, "%s", ctx->parms);
+    gchar *cmd_line = g_strdup_printf("sysbench %s %s run", ctx->parms, ctx->test);
+    spawned = g_spawn_command_line_sync(cmd_line,
+            &out, &err, NULL, NULL);
+    if (spawned) {
+        p = out;
+        while(next_nl = strchr(p, '\n')) {
+            *next_nl = 0;
+
+            /* version */
+            mc = sscanf(p, "sysbench %d.%d.%d", &v1, &v2, &v3);
+            if (mc >= 1) {
+                ctx->r.revision = 0;
+                ctx->r.revision += v1 * 1000000;
+                ctx->r.revision += v2 * 1000;
+                ctx->r.revision += v3;
+            }
+
+            /* total_time */
+            if (pp = strstr(p, "total time:")) {
+                pp = strchr(pp, ':') + 1;
+                ctx->r.elapsed_time = strtof(pp, NULL);
+            }
+
+            /* result */
+            if (SEQ(ctx->test, "memory") ) {
+                // 57894.30 MiB transferred (5787.59 MiB/sec)
+                if (pp = strstr(p, " transferred (")) {
+                    pp = strchr(pp, '(') + 1;
+                    ctx->r.result = strtof(pp, NULL);
+                }
+            }
+
+            p = next_nl + 1;
+        }
+        g_free(out);
+        g_free(err);
+    }
+
+    g_free(cmd_line);
+    return spawned;
+}
+
+void benchmark_memory_single(void)
+{
+    struct sysbench_ctx ctx = {
+        .test = "memory",
+        .parms = "--threads=1 --time=7"
+           " --memory-block-size=1K"
+           " --memory-total-size=100G"
+           " --memory-scope=global"
+           " --memory-hugetlb=off"
+           " --memory-oper=write"
+           " --memory-access-mode=seq",
+        .r = EMPTY_BENCH_VALUE};
+    ctx.r.threads_used = 1;
+
+    shell_view_set_enabled(FALSE);
+    shell_status_update("Performing Alexey Kopytov's sysbench memory benchmark (single thread)...");
+
+    sysbench_run(&ctx);
+    bench_results[BENCHMARK_MEMORY_SINGLE] = ctx.r;
+}
+
+void benchmark_memory_dual(void)
+{
+    struct sysbench_ctx ctx = {
+        .test = "memory",
+        .parms = "--threads=2 --time=7"
+           " --memory-block-size=1K"
+           " --memory-total-size=100G"
+           " --memory-scope=global"
+           " --memory-hugetlb=off"
+           " --memory-oper=write"
+           " --memory-access-mode=seq",
+        .r = EMPTY_BENCH_VALUE};
+    ctx.r.threads_used = 2;
+
+    shell_view_set_enabled(FALSE);
+    shell_status_update("Performing Alexey Kopytov's sysbench memory benchmark (two threads)...");
+
+    sysbench_run(&ctx);
+    bench_results[BENCHMARK_MEMORY_DUAL] = ctx.r;
+}
+
+void benchmark_memory_quad(void)
+{
+    struct sysbench_ctx ctx = {
+        .test = "memory",
+        .parms = "--threads=4 --time=7"
+           " --memory-block-size=1K"
+           " --memory-total-size=100G"
+           " --memory-scope=global"
+           " --memory-hugetlb=off"
+           " --memory-oper=write"
+           " --memory-access-mode=seq",
+        .r = EMPTY_BENCH_VALUE};
+    ctx.r.threads_used = 4;
+
+    shell_view_set_enabled(FALSE);
+    shell_status_update("Performing Alexey Kopytov's sysbench memory benchmark (four threads)...");
+
+    sysbench_run(&ctx);
+    bench_results[BENCHMARK_MEMORY_QUAD] = ctx.r;
+}