New upstream version 2.0.3preupstream/2.0.3pre

1 files changed, 582 insertions, 356 deletions

diff --git a/modules/benchmark.c b/modules/benchmark.c
index 26de9557..018e30fe 100644
--- a/modules/benchmark.c
+++ b/modules/benchmark.c
@@ -1,10 +1,10 @@
 /*
  *    HardInfo - Displays System Information
- *    Copyright (C) 2003-2009 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *    Copyright (C) 2003-2009 L. A. F. Pereira <l@tia.mat.br>
  *
  *    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.
+ *    the Free Software Foundation, version 2 or later.
  *
  *    This program is distributed in the hope that it will be useful,
  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,48 +16,84 @@
  *    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
+#define _GNU_SOURCE
+#include <config.h>
 #include <hardinfo.h>
 #include <iconcache.h>
 #include <shell.h>
-#include <config.h>
 #include <syncmanager.h>
 
-#include <sys/time.h>
 #include <sys/resource.h>
+#include <sys/time.h>
 
-#include <sys/types.h>
 #include <signal.h>
+#include <sys/types.h>
 
+#include "appf.h"
 #include "benchmark.h"
+#include "cpu_util.h"
 
 #include "benchmark/bench_results.c"
 
 bench_value bench_results[BENCHMARK_N_ENTRIES];
 
 static void do_benchmark(void (*benchmark_function)(void), int entry);
-static gchar *benchmark_include_results_reverse(bench_value result, const gchar * benchmark);
-static gchar *benchmark_include_results(bench_value result, const gchar * benchmark);
+static gchar *benchmark_include_results_reverse(bench_value result,
+                                                const gchar *benchmark);
+static gchar *benchmark_include_results(bench_value result,
+                                        const gchar *benchmark);
 
 /* ModuleEntry entries, scan_*(), callback_*(), etc. */
 #include "benchmark/benches.c"
 
-static gboolean sending_benchmark_results = FALSE;
-
-char *bench_value_to_str(bench_value r) {
-    return g_strdup_printf("%lf; %lf; %d", r.result, r.elapsed_time, r.threads_used);
+char *bench_value_to_str(bench_value r)
+{
+    gboolean has_rev = r.revision >= 0;
+    gboolean has_extra = r.extra && *r.extra != 0;
+    gboolean has_user_note = r.user_note && *r.user_note != 0;
+    char *ret = g_strdup_printf("%lf; %lf; %d", r.result, r.elapsed_time,
+                                r.threads_used);
+    if (has_rev || has_extra || has_user_note)
+        ret = appf(ret, "; ", "%d", r.revision);
+    if (has_extra || has_user_note)
+        ret = appf(ret, "; ", "%s", r.extra);
+    if (has_user_note)
+        ret = appf(ret, "; ", "%s", r.user_note);
+    return ret;
 }
 
-bench_value bench_value_from_str(const char* str) {
+bench_value bench_value_from_str(const char *str)
+{
     bench_value ret = EMPTY_BENCH_VALUE;
-    double r, e;
-    int t, c;
+    char rstr[32] = "", estr[32] = "", *p;
+    int t, c, v;
+    char extra[256], user_note[256];
     if (str) {
-        c = sscanf(str, "%lf; %lf; %d", &r, &e, &t);
+        /* try to handle floats from locales that use ',' or '.' as decimal sep
+         */
+        c = sscanf(
+            str, "%[-+0-9.,]; %[-+0-9.,]; %d; %d; %255[^\r\n;|]; %255[^\r\n;|]",
+            rstr, estr, &t, &v, extra, user_note);
         if (c >= 3) {
-            ret.result = r;
-            ret.elapsed_time = e;
+            if ((p = strchr(rstr, ','))) {
+                *p = '.';
+            }
+            if ((p = strchr(estr, ','))) {
+                *p = '.';
+            }
+            ret.result = g_ascii_strtod(rstr, NULL);
+            ret.elapsed_time = g_ascii_strtod(estr, NULL);
             ret.threads_used = t;
         }
+        if (c >= 4) {
+            ret.revision = v;
+        }
+        if (c >= 5) {
+            strcpy(ret.extra, extra);
+        }
+        if (c >= 6) {
+            strcpy(ret.user_note, user_note);
+        }
     }
     return ret;
 }
@@ -65,46 +101,51 @@ bench_value bench_value_from_str(const char* str) {
 typedef struct _ParallelBenchTask ParallelBenchTask;
 
 struct _ParallelBenchTask {
-    gint	thread_number;
-    guint	start, end;
-    gpointer	data, callback;
+    gint thread_number;
+    guint start, end;
+    gpointer data, callback;
     int *stop;
 };
 
 static gpointer benchmark_crunch_for_dispatcher(gpointer data)
 {
-    ParallelBenchTask 	*pbt = (ParallelBenchTask *)data;
+    ParallelBenchTask *pbt = (ParallelBenchTask *)data;
     gpointer (*callback)(void *data, gint thread_number);
-    gpointer return_value = g_malloc(sizeof(int));
+    gpointer return_value = g_malloc(sizeof(double));
     int count = 0;
 
     if ((callback = pbt->callback)) {
-        while(!*pbt->stop) {
+        while (!*pbt->stop) {
             callback(pbt->data, pbt->thread_number);
             /* don't count if didn't finish in time */
             if (!*pbt->stop)
                 count++;
         }
     } else {
-        DEBUG("this is thread %p; callback is NULL and it should't be!", g_thread_self());
+        DEBUG("this is thread %p; callback is NULL and it should't be!",
+              g_thread_self());
     }
 
     g_free(pbt);
 
-    *(double*)return_value = (double)count;
+    *(double *)return_value = (double)count;
     return return_value;
 }
 
-bench_value benchmark_crunch_for(float seconds, gint n_threads,
-                               gpointer callback, gpointer callback_data) {
-    int cpu_procs, cpu_cores, cpu_threads, thread_number, stop = 0;
+bench_value benchmark_crunch_for(float seconds,
+                                 gint n_threads,
+                                 gpointer callback,
+                                 gpointer callback_data)
+{
+    int cpu_procs, cpu_cores, cpu_threads, cpu_nodes;
+    int thread_number, stop = 0;
     GSList *threads = NULL, *t;
     GTimer *timer;
     bench_value ret = EMPTY_BENCH_VALUE;
 
     timer = g_timer_new();
 
-    cpu_procs_cores_threads(&cpu_procs, &cpu_cores, &cpu_threads);
+    cpu_procs_cores_threads_nodes(&cpu_procs, &cpu_cores, &cpu_threads, &cpu_nodes);
     if (n_threads > 0)
         ret.threads_used = n_threads;
     else if (n_threads < 0)
@@ -120,19 +161,22 @@ bench_value benchmark_crunch_for(float seconds, gint n_threads,
         DEBUG("launching thread %d", thread_number);
 
         pbt->thread_number = thread_number;
-        pbt->data     = callback_data;
+        pbt->data = callback_data;
         pbt->callback = callback;
         pbt->stop = &stop;
 
-        thread = g_thread_new("dispatcher",
-            (GThreadFunc)benchmark_crunch_for_dispatcher, pbt);
+#if GLIB_CHECK_VERSION(2,32,0)
+        thread = g_thread_new("dispatcher", (GThreadFunc)benchmark_crunch_for_dispatcher, pbt);
+#else
+        thread = g_thread_create((GThreadFunc)benchmark_crunch_for_dispatcher, pbt,TRUE,NULL);
+#endif
         threads = g_slist_prepend(threads, thread);
 
         DEBUG("thread %d launched as context %p", thread_number, thread);
     }
 
     /* wait for time */
-    //while ( g_timer_elapsed(timer, NULL) < seconds ) { }
+    // while ( g_timer_elapsed(timer, NULL) < seconds ) { }
     g_usleep(seconds * 1000000);
 
     /* signal all threads to stop */
@@ -144,7 +188,7 @@ bench_value benchmark_crunch_for(float seconds, gint n_threads,
     for (t = threads; t; t = t->next) {
         DEBUG("waiting for thread with context %p", t->data);
         gpointer *rv = g_thread_join((GThread *)t->data);
-        ret.result += *(double*)rv;
+        ret.result += *(double *)rv;
         g_free(rv);
     }
 
@@ -158,17 +202,21 @@ bench_value benchmark_crunch_for(float seconds, gint n_threads,
 
 static gpointer benchmark_parallel_for_dispatcher(gpointer data)
 {
-    ParallelBenchTask 	*pbt = (ParallelBenchTask *)data;
-    gpointer 		(*callback)(unsigned int start, unsigned int end, void *data, gint thread_number);
-    gpointer		return_value = NULL;
+    ParallelBenchTask *pbt = (ParallelBenchTask *)data;
+    gpointer (*callback)(unsigned int start, unsigned int end, void *data,
+                         gint thread_number);
+    gpointer return_value = NULL;
 
     if ((callback = pbt->callback)) {
         DEBUG("this is thread %p; items %d -> %d, data %p", g_thread_self(),
               pbt->start, pbt->end, pbt->data);
-        return_value = callback(pbt->start, pbt->end, pbt->data, pbt->thread_number);
-        DEBUG("this is thread %p; return value is %p", g_thread_self(), return_value);
+        return_value =
+            callback(pbt->start, pbt->end, pbt->data, pbt->thread_number);
+        DEBUG("this is thread %p; return value is %p", g_thread_self(),
+              return_value);
     } else {
-        DEBUG("this is thread %p; callback is NULL and it should't be!", g_thread_self());
+        DEBUG("this is thread %p; callback is NULL and it should't be!",
+              g_thread_self());
     }
 
     g_free(pbt);
@@ -177,31 +225,43 @@ static gpointer benchmark_parallel_for_dispatcher(gpointer data)
 }
 
 /* one call for each thread to be used */
-bench_value benchmark_parallel(gint n_threads, gpointer callback, gpointer callback_data) {
-    int cpu_procs, cpu_cores, cpu_threads;
-    cpu_procs_cores_threads(&cpu_procs, &cpu_cores, &cpu_threads);
-    if (n_threads == 0) n_threads = cpu_threads;
-    else if (n_threads == -1) n_threads = cpu_cores;
-    return  benchmark_parallel_for(n_threads, 0, n_threads, callback, callback_data);
+bench_value
+benchmark_parallel(gint n_threads, gpointer callback, gpointer callback_data)
+{
+    int cpu_procs, cpu_cores, cpu_threads, cpu_nodes;
+    cpu_procs_cores_threads_nodes(&cpu_procs, &cpu_cores, &cpu_threads, &cpu_nodes);
+
+    if (n_threads == 0)
+        n_threads = cpu_threads;
+    else if (n_threads == -1)
+        n_threads = cpu_cores;
+
+    return benchmark_parallel_for(n_threads, 0, n_threads, callback,
+                                  callback_data);
 }
 
 /* Note:
  *    benchmark_parallel_for(): element [start] included, but [end] is excluded.
- *    callback(): expected to processes elements [start] through [end] inclusive.
+ *    callback(): expected to processes elements [start] through [end]
+ * inclusive.
  */
-bench_value benchmark_parallel_for(gint n_threads, guint start, guint end,
-                               gpointer callback, gpointer callback_data) {
-    gchar	*temp;
-    int 	cpu_procs, cpu_cores, cpu_threads;
-    guint	iter_per_thread, iter, thread_number = 0;
-    GSList	*threads = NULL, *t;
-    GTimer	*timer;
+bench_value benchmark_parallel_for(gint n_threads,
+                                   guint start,
+                                   guint end,
+                                   gpointer callback,
+                                   gpointer callback_data)
+{
+    gchar *temp;
+    int cpu_procs, cpu_cores, cpu_threads, cpu_nodes;
+    guint iter_per_thread, iter, thread_number = 0;
+    GSList *threads = NULL, *t;
+    GTimer *timer;
 
     bench_value ret = EMPTY_BENCH_VALUE;
 
     timer = g_timer_new();
 
-    cpu_procs_cores_threads(&cpu_procs, &cpu_cores, &cpu_threads);
+    cpu_procs_cores_threads_nodes(&cpu_procs, &cpu_cores, &cpu_threads, &cpu_nodes);
 
     if (n_threads > 0)
         ret.threads_used = n_threads;
@@ -214,18 +274,19 @@ bench_value benchmark_parallel_for(gint n_threads, guint start, guint end,
         iter_per_thread = (end - start) / ret.threads_used;
 
         if (iter_per_thread == 0) {
-          DEBUG("not enough items per thread; disabling one thread");
-          ret.threads_used--;
+            DEBUG("not enough items per thread; disabling one thread");
+            ret.threads_used--;
         } else {
-          break;
+            break;
         }
     }
 
-    DEBUG("Using %d threads across %d logical processors; processing %d elements (%d per thread)",
+    DEBUG("Using %d threads across %d logical processors; processing %d "
+          "elements (%d per thread)",
           ret.threads_used, cpu_threads, (end - start), iter_per_thread);
 
     g_timer_start(timer);
-    for (iter = start; iter < end; ) {
+    for (iter = start; iter < end;) {
         ParallelBenchTask *pbt = g_new0(ParallelBenchTask, 1);
         GThread *thread;
 
@@ -238,13 +299,17 @@ bench_value benchmark_parallel_for(gint n_threads, guint start, guint end,
         DEBUG("launching thread %d", 1 + thread_number);
 
         pbt->thread_number = thread_number++;
-        pbt->start    = ts;
-        pbt->end      = te - 1;
-        pbt->data     = callback_data;
+        pbt->start = ts;
+        pbt->end = te - 1;
+        pbt->data = callback_data;
         pbt->callback = callback;
 
-        thread = g_thread_new("dispatcher",
-            (GThreadFunc)benchmark_parallel_for_dispatcher, pbt);
+#if GLIB_CHECK_VERSION(2,32,0)
+        thread = g_thread_new("dispatcher", (GThreadFunc)benchmark_parallel_for_dispatcher, pbt);
+#else
+        thread = g_thread_create((GThreadFunc)benchmark_parallel_for_dispatcher, pbt,TRUE,NULL);
+#endif
+
         threads = g_slist_prepend(threads, thread);
 
         DEBUG("thread %d launched as context %p", thread_number, thread);
@@ -255,8 +320,9 @@ bench_value benchmark_parallel_for(gint n_threads, guint start, guint end,
         DEBUG("waiting for thread with context %p", t->data);
         gpointer *rv = g_thread_join((GThread *)t->data);
         if (rv) {
-            if (ret.result == -1.0) ret.result = 0;
-            ret.result += *(double*)rv;
+            if (ret.result == -1.0)
+                ret.result = 0;
+            ret.result += *(double *)rv;
         }
         g_free(rv);
     }
@@ -272,140 +338,256 @@ bench_value benchmark_parallel_for(gint n_threads, guint start, guint end,
     return ret;
 }
 
-static gchar *clean_cpuname(gchar *cpuname)
+gchar *hi_more_info(gchar *entry)
 {
-    gchar *ret = NULL, *tmp;
-    gchar *remove[] = {
-        "(R)", "(r)", "(TM)", "(tm)", "Processor",
-        "Technology", "processor", "CPU",
-        "cpu", "Genuine", "Authentic", NULL
-    };
-    gint i;
+    const gchar *info = moreinfo_lookup_with_prefix("BENCH", entry);
+    return g_strdup(info ? info : "?");
+}
+
+gchar *hi_get_field(gchar *field)
+{
+    const gchar *info = moreinfo_lookup_with_prefix("BENCH", field);
+    return g_strdup(info ? info : field);
+}
 
-    ret = g_strdup(cpuname);
-    for (i = 0; remove[i]; i++) {
-      tmp = strreplace(ret, remove[i], "");
-      g_free(ret);
-      ret = tmp;
+static void br_mi_add(char **results_list, bench_result *b, gboolean select)
+{
+    static unsigned int ri = 0; /* to ensure key is unique */
+    gchar *rkey, *lbl, *elbl, *this_marker;
+
+    if (select) {
+        this_marker = format_with_ansi_color(_("This Machine"), "0;30;43",
+                                             params.fmt_opts);
+    } else {
+        this_marker = "";
     }
 
-    ret = strend(ret, '@');
-    ret = g_strstrip(ret);
+    rkey = g_strdup_printf("%s__%d", b->machine->mid, ri++);
 
-    tmp = g_strdup(ret);
-    g_free(ret);
+    lbl = g_strdup_printf("%s%s%s%s", this_marker, select ? " " : "",
+                          b->machine->cpu_name,
+                          b->legacy ? problem_marker() : "");
+    elbl = key_label_escape(lbl);
 
-    return tmp;
-}
+    *results_list = h_strdup_cprintf("$@%s%s$%s=%.2f|%s\n", *results_list,
+                                     select ? "*" : "", rkey, elbl,
+                                     b->bvalue.result, b->machine->cpu_config);
 
-gchar *hi_more_info(gchar * entry)
+    moreinfo_add_with_prefix("BENCH", rkey, bench_result_more_info(b));
+
+    g_free(lbl);
+    g_free(elbl);
+    g_free(rkey);
+    if (*this_marker)
+        g_free(this_marker);
+}
+gint bench_result_sort(gconstpointer a, gconstpointer b)
 {
-    gchar *info = moreinfo_lookup_with_prefix("BENCH", entry);
-    if (info)
-        return g_strdup(info);
-    return g_strdup("?");
+    bench_result *A = (bench_result *)a, *B = (bench_result *)b;
+    if (A->bvalue.result < B->bvalue.result)
+        return -1;
+    if (A->bvalue.result > B->bvalue.result)
+        return 1;
+    return 0;
 }
 
-gchar *hi_get_field(gchar * field)
+struct append_machine_result_json_data {
+    GSList **result_list;
+    const gchar *benchmark_name;
+};
+
+static void append_machine_result_json(JsonArray *array,
+                                       guint index,
+                                       JsonNode *element_node,
+                                       gpointer user_data)
 {
-    gchar *info = moreinfo_lookup_with_prefix("BENCH", field);
-    if (info)
-        return g_strdup(info);
-    return g_strdup(field);
+    struct append_machine_result_json_data *data = user_data;
+    bench_result *result;
+
+    result = bench_result_benchmarkjson(data->benchmark_name, element_node);
+    *data->result_list = g_slist_append(*data->result_list, result);
 }
 
-static void br_mi_add(char **results_list, bench_result *b, gboolean select) {
-    gchar *ckey, *rkey;
+static GSList *benchmark_include_results_json(const gchar *path,
+                                              bench_value r,
+                                              const gchar *benchmark)
+{
+    JsonParser *parser;
+    JsonNode *root;
+    bench_result *this_machine = NULL;
+    GSList *result_list = NULL;
+    GError *error=NULL;
+
+    DEBUG("Loading benchmark results from JSON file %s", path);
+
+    parser = json_parser_new();
+    json_parser_load_from_file(parser, path, &error);
+    if(error){
+        DEBUG ("Unable to parse JSON %s %s", path, error->message);
+        g_error_free(error);
+        g_object_unref(parser);
+        return result_list;
+    }
 
-    ckey = hardinfo_clean_label(b->machine->cpu_name, 0);
-    rkey = strdup(b->machine->mid);
+    root = json_parser_get_root(parser);
+    if (json_node_get_node_type(root) != JSON_NODE_OBJECT)  goto out;
 
-    *results_list = h_strdup_cprintf("$%s%s$%s=%.2f|%s\n", *results_list,
-        select ? "*" : "", rkey, ckey,
-        b->bvalue.result, b->machine->cpu_config);
+    JsonObject *results = json_node_get_object(root);
+    if (results) {
+        JsonArray *machines = json_object_get_array_member(results, benchmark);
 
-    moreinfo_add_with_prefix("BENCH", rkey, bench_result_more_info(b) );
+        if (machines) {
+            struct append_machine_result_json_data data = {
+                .result_list = &result_list,
+                .benchmark_name = benchmark,
+            };
+            json_array_foreach_element(machines, append_machine_result_json,
+                                       &data);
+        }
+    }
 
-    g_free(ckey);
-    g_free(rkey);
+out:
+    g_object_unref(parser);
+
+    return result_list;
 }
 
-static gchar *__benchmark_include_results(bench_value r,
-					  const gchar * benchmark,
-					  ShellOrderType order_type)
+static gchar *find_benchmark_conf(void)
 {
-    bench_result *b = NULL;
-    GKeyFile *conf;
-    gchar **machines, *temp = NULL;;
-    gchar *path, *results = g_strdup(""), *return_value, *processor_frequency, *processor_name;
-    int i, n_threads;
+    const gchar *config_dir = g_get_user_config_dir();
+    gchar *path;
 
-    moreinfo_del_with_prefix("BENCH");
+    path = g_build_filename(config_dir, "hardinfo2", "benchmark.json", NULL);
+    if (g_file_test(path, G_FILE_TEST_EXISTS))
+        return path;
+    g_free(path);
 
-    if (r.result > 0.0) {
-        b = bench_result_this_machine(benchmark, r);
-        br_mi_add(&results, b, 1);
+    path = g_build_filename(params.path_data, "benchmark.json", NULL);
+    if (g_file_test(path, G_FILE_TEST_EXISTS))
+        return path;
+    g_free(path);
+
+    return NULL;
+}
 
-        temp = bench_result_benchmarkconf_line(b);
-        printf("[%s]\n%s", benchmark, temp);
-        g_free(temp); temp = NULL;
+struct bench_window {
+    int min, max;
+};
+
+static struct bench_window get_bench_window(GSList *result_list,
+                                            const bench_result *this_machine)
+{
+    struct bench_window window = {};
+    int size = params.max_bench_results;
+    int len = g_slist_length(result_list);
+
+    if (size == 0)
+        size = 1;
+    else if (size < 0)
+        size = len;
+
+    int loc = g_slist_index(result_list, this_machine); /* -1 if not found */
+    if (loc >= 0) {
+        window.min = loc - size / 2;
+        window.max = window.min + size;
+        if (window.min < 0) {
+            window.min = 0;
+            window.max = MIN(size, len);
+        } else if (window.max > len) {
+            window.max = len;
+            window.min = MAX(len - size, 0);
+        }
+    } else {
+        window.min = 0;
+        window.max = len;
     }
 
-    conf = g_key_file_new();
+    DEBUG("...len: %d, loc: %d, win_size: %d, win: [%d..%d]\n", len, loc, size,
+          window.min, window.max - 1);
+
+    return window;
+}
+
+static gboolean is_in_bench_window(const struct bench_window *window, int i)
+{
+    return i >= window->min && i < window->max;
+}
 
-    path = g_build_filename(g_get_home_dir(), ".hardinfo", "benchmark.conf", NULL);
-    if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
-        DEBUG("local benchmark.conf not found, trying system-wide");
-        g_free(path);
-        path = g_build_filename(params.path_data, "benchmark.conf", NULL);
+static gchar *benchmark_include_results_internal(bench_value this_machine_value,
+                                                 const gchar *benchmark,
+                                                 ShellOrderType order_type)
+{
+    bench_result *this_machine;
+    GSList *result_list, *li;
+    gchar *results = g_strdup("");
+    gchar *output;
+    gchar *path;
+    gint i;
+
+    path = find_benchmark_conf();
+    if (path) {
+        result_list = benchmark_include_results_json(
+            path, this_machine_value, benchmark);
     }
 
-    g_key_file_load_from_file(conf, path, 0, NULL);
-    g_key_file_set_list_separator(conf, '|');
+    /* this result */
+    if (this_machine_value.result > 0.0) {
+        this_machine = bench_result_this_machine(benchmark, this_machine_value);
+        result_list = g_slist_prepend(result_list, this_machine);
+    } else {
+        this_machine = NULL;
+    }
 
-    machines = g_key_file_get_keys(conf, benchmark, NULL, NULL);
-    for (i = 0; machines && machines[i]; i++) {
-        gchar **values;
-        bench_result *sbr;
+    /* sort */
+    result_list = g_slist_sort(result_list, bench_result_sort);
+    if (order_type == SHELL_ORDER_DESCENDING)
+        result_list = g_slist_reverse(result_list);
 
-        values = g_key_file_get_string_list(conf, benchmark, machines[i], NULL, NULL);
+    /* prepare for shell */
+    moreinfo_del_with_prefix("BENCH");
+
+    const struct bench_window window =
+        get_bench_window(result_list, this_machine);
+    for (i = 0, li = result_list; li; li = g_slist_next(li), i++) {
+        bench_result *br = li->data;
 
-        sbr = bench_result_benchmarkconf(benchmark, machines[i], values);
-        br_mi_add(&results, sbr, 0);
+        if (is_in_bench_window(&window, i))
+            br_mi_add(&results, br, br == this_machine);
 
-        bench_result_free(sbr);
-        g_strfreev(values);
+        bench_result_free(br); /* no longer needed */
     }
+    g_slist_free(result_list);
+
+    output = g_strdup_printf("[$ShellParam$]\n"
+                             "Zebra=1\n"
+                             "OrderType=%d\n"
+                             "ViewType=4\n"
+                             "ColumnTitle$Extra1=%s\n"    /* CPU Clock */
+                             "ColumnTitle$Progress=%s\n"  /* Results */
+                             "ColumnTitle$TextValue=%s\n" /* CPU */
+                             "ShowColumnHeaders=true\n"
+                             "[%s]\n%s",
+                             order_type, _("CPU Config"), _("Results"),
+                             _("CPU"), benchmark, results);
 
-    g_strfreev(machines);
     g_free(path);
-    g_key_file_free(conf);
-
-    return_value = g_strdup_printf("[$ShellParam$]\n"
-                   "Zebra=1\n"
-                   "OrderType=%d\n"
-                   "ViewType=4\n"
-                   "ColumnTitle$Extra1=%s\n" /* CPU Clock */
-                   "ColumnTitle$Progress=%s\n" /* Results */
-                   "ColumnTitle$TextValue=%s\n" /* CPU */
-                   "ShowColumnHeaders=true\n"
-                   "[%s]\n%s",
-                   order_type,
-                   _("CPU Config"), _("Results"), _("CPU"),
-                   benchmark, results);
-
-    bench_result_free(b);
-    return return_value;
+    g_free(results);
+
+    return output;
 }
 
-static gchar *benchmark_include_results_reverse(bench_value result, const gchar * benchmark)
+static gchar *benchmark_include_results_reverse(bench_value result,
+                                                const gchar *benchmark)
 {
-    return __benchmark_include_results(result, benchmark, SHELL_ORDER_DESCENDING);
+    return benchmark_include_results_internal(result, benchmark,
+                                              SHELL_ORDER_DESCENDING);
 }
 
-static gchar *benchmark_include_results(bench_value result, const gchar * benchmark)
+static gchar *benchmark_include_results(bench_value result,
+                                        const gchar *benchmark)
 {
-    return __benchmark_include_results(result, benchmark, SHELL_ORDER_ASCENDING);
+    return benchmark_include_results_internal(result, benchmark,
+                                              SHELL_ORDER_ASCENDING);
 }
 
 typedef struct _BenchmarkDialog BenchmarkDialog;
@@ -414,11 +596,10 @@ struct _BenchmarkDialog {
     bench_value r;
 };
 
-static gboolean do_benchmark_handler(GIOChannel *source,
-                                     GIOCondition condition,
-                                     gpointer data)
+static gboolean
+do_benchmark_handler(GIOChannel *source, GIOCondition condition, gpointer data)
 {
-    BenchmarkDialog *bench_dialog = (BenchmarkDialog*)data;
+    BenchmarkDialog *bench_dialog = (BenchmarkDialog *)data;
     GIOStatus status;
     gchar *result;
     bench_value r = EMPTY_BENCH_VALUE;
@@ -433,6 +614,9 @@ static gboolean do_benchmark_handler(GIOChannel *source,
     }
 
     r = bench_value_from_str(result);
+    /* attach a user note */
+    if (params.bench_user_note)
+        strncpy(r.user_note, params.bench_user_note, 255);
     bench_dialog->r = r;
 
     gtk_widget_destroy(bench_dialog->dialog);
@@ -445,118 +629,127 @@ static void do_benchmark(void (*benchmark_function)(void), int entry)
 {
     int old_priority = 0;
 
-    if (params.gui_running && !sending_benchmark_results) {
-       gchar *argv[] = { params.argv0, "-b", entries[entry].name,
-                         "-m", "benchmark.so", "-a", NULL };
-       GPid bench_pid;
-       gint bench_stdout;
-       GtkWidget *bench_dialog;
-       GtkWidget *bench_image;
-       BenchmarkDialog *benchmark_dialog;
-       GSpawnFlags spawn_flags = G_SPAWN_STDERR_TO_DEV_NULL;
-       gchar *bench_status;
-
-       bench_value r = EMPTY_BENCH_VALUE;
-       bench_results[entry] = r;
-
-       bench_status = g_strdup_printf(_("Benchmarking: <b>%s</b>."), entries[entry].name);
-
-       shell_view_set_enabled(FALSE);
-       shell_status_update(bench_status);
-
-       g_free(bench_status);
-
-       bench_image = icon_cache_get_image("benchmark.png");
-       gtk_widget_show(bench_image);
-
-#if GTK_CHECK_VERSION(3, 0, 0)
-       GtkWidget *button;
-       GtkWidget *content_area;
-       GtkWidget *hbox;
-       GtkWidget *label;
-
-       bench_dialog = gtk_dialog_new_with_buttons("",
-                                                  NULL,
-                                                  GTK_DIALOG_MODAL,
-                                                  _("Cancel"),
-                                                  GTK_RESPONSE_ACCEPT,
-                                                  NULL);
-       content_area = gtk_dialog_get_content_area(GTK_DIALOG(bench_dialog));
-       label = gtk_label_new(_("Benchmarking. Please do not move your mouse " \
-                                             "or press any keys."));
-       hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
-       gtk_box_pack_start(GTK_BOX(hbox), bench_image, TRUE, TRUE, 5);
-       gtk_box_pack_end(GTK_BOX(hbox), label, TRUE, TRUE, 5);
-       gtk_container_add(GTK_CONTAINER (content_area), hbox);
-       gtk_widget_show_all(bench_dialog);
+    if (params.skip_benchmarks)
+        return;
+
+    if (params.gui_running) {
+        gchar *argv[] = {params.argv0, "-b",           entries[entry].name,
+                         "-m",         "benchmark.so", "-a",
+                         NULL};
+        GPid bench_pid;
+        gint bench_stdout;
+        GtkWidget *bench_dialog;
+        GtkWidget *bench_image;
+        BenchmarkDialog *benchmark_dialog;
+        GSpawnFlags spawn_flags = G_SPAWN_STDERR_TO_DEV_NULL;
+        gchar *bench_status;
+        GtkWidget *content_area, *box, *label;
+        bench_value r = EMPTY_BENCH_VALUE;
+        bench_results[entry] = r;
+
+        bench_status =
+            g_strdup_printf(_("Benchmarking: <b>%s</b>."), entries[entry].name);
+
+        shell_view_set_enabled(FALSE);
+        shell_status_update(bench_status);
+
+        g_free(bench_status);
+
+        bench_image = icon_cache_get_image("benchmark.png");
+
+	bench_dialog = gtk_dialog_new_with_buttons ("Benchmarking...",
+                                      GTK_WINDOW(shell_get_main_shell()->transient_dialog),
+                                      GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
+                                      "Stop",
+                                      GTK_BUTTONS_CLOSE,
+                                      NULL);
+
+	gtk_widget_set_sensitive(GTK_WIDGET(shell_get_main_shell()->transient_dialog), FALSE);
+
+	content_area = gtk_dialog_get_content_area (GTK_DIALOG(bench_dialog));
+
+#if GTK_CHECK_VERSION(3,0,0)
+	box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1);
 #else
-       bench_dialog = gtk_message_dialog_new(GTK_WINDOW(shell_get_main_shell()->window),
-                                             GTK_DIALOG_MODAL,
-                                             GTK_MESSAGE_INFO,
-                                             GTK_BUTTONS_NONE,
-                                             _("Benchmarking. Please do not move your mouse " \
-                                             "or press any keys."));
-       gtk_dialog_add_buttons(GTK_DIALOG(bench_dialog),
-                              _("Cancel"), GTK_RESPONSE_ACCEPT, NULL);
-       gtk_message_dialog_set_image(GTK_MESSAGE_DIALOG(bench_dialog), bench_image);
+	box = gtk_hbox_new(FALSE, 1);
 #endif
+	label = gtk_label_new ("Please do not move your mouse\n"
+	    "or press any keys.");
 
-       while (gtk_events_pending()) {
-         gtk_main_iteration();
-       }
+	gtk_widget_show (bench_image);
 
-       benchmark_dialog = g_new0(BenchmarkDialog, 1);
-       benchmark_dialog->dialog = bench_dialog;
-       benchmark_dialog->r = r;
+#if GTK_CHECK_VERSION(3,0,0)
+	gtk_widget_set_halign (bench_image, GTK_ALIGN_START);
+#else
+        gtk_misc_set_alignment(GTK_MISC(bench_image), 0.0, 0.0);
+#endif
+
+	g_signal_connect_swapped (bench_dialog,
+				  "response",
+				  G_CALLBACK (gtk_widget_destroy),
+				  bench_dialog);
 
-       if (!g_path_is_absolute(params.argv0)) {
-          spawn_flags |= G_SPAWN_SEARCH_PATH;
-       }
+	gtk_box_pack_start (GTK_BOX(box), bench_image, TRUE, TRUE, 10);
+	gtk_box_pack_start (GTK_BOX(box), label, TRUE, TRUE, 10);
+	gtk_container_add (GTK_CONTAINER(content_area), box);
 
-       if (g_spawn_async_with_pipes(NULL,
-                                    argv, NULL,
-                                    spawn_flags,
-                                    NULL, NULL,
-                                    &bench_pid,
-                                    NULL, &bench_stdout, NULL,
-                                    NULL)) {
-          GIOChannel *channel;
-          guint watch_id;
+	gtk_window_set_deletable(GTK_WINDOW(bench_dialog), FALSE);
+	gtk_widget_show_all (bench_dialog);
 
-          DEBUG("spawning benchmark; pid=%d", bench_pid);
+        while (gtk_events_pending()) {
+            gtk_main_iteration();
+        }
 
-          channel = g_io_channel_unix_new(bench_stdout);
-          watch_id = g_io_add_watch(channel, G_IO_IN, do_benchmark_handler,
-                                    benchmark_dialog);
+        benchmark_dialog = g_new0(BenchmarkDialog, 1);
+        benchmark_dialog->dialog = bench_dialog;
+        benchmark_dialog->r = r;
 
-          switch (gtk_dialog_run(GTK_DIALOG(bench_dialog))) {
+        if (!g_path_is_absolute(params.argv0)) {
+            spawn_flags |= G_SPAWN_SEARCH_PATH;
+        }
+
+        if (g_spawn_async_with_pipes(NULL, argv, NULL, spawn_flags, NULL, NULL,
+                                     &bench_pid, NULL, &bench_stdout, NULL,
+                                     NULL)) {
+            GIOChannel *channel;
+            guint watch_id;
+
+            DEBUG("spawning benchmark; pid=%d", bench_pid);
+
+            channel = g_io_channel_unix_new(bench_stdout);
+            watch_id = g_io_add_watch(channel, G_IO_IN, do_benchmark_handler,
+                                      benchmark_dialog);
+
+            switch (gtk_dialog_run(GTK_DIALOG(bench_dialog))) {
             case GTK_RESPONSE_NONE:
-              DEBUG("benchmark finished");
-              break;
+                DEBUG("benchmark finished");
+                break;
             case GTK_RESPONSE_ACCEPT:
-              DEBUG("cancelling benchmark");
+                DEBUG("cancelling benchmark");
 
-              gtk_widget_destroy(bench_dialog);
-              g_source_remove(watch_id);
-              kill(bench_pid, SIGINT);
-          }
+                gtk_widget_destroy(bench_dialog);
+                g_source_remove(watch_id);
+                kill(bench_pid, SIGINT);
+            }
 
-          bench_results[entry] = benchmark_dialog->r;
+            bench_results[entry] = benchmark_dialog->r;
 
-          g_io_channel_unref(channel);
-          shell_view_set_enabled(TRUE);
-          shell_status_set_enabled(TRUE);
-          g_free(benchmark_dialog);
+            g_io_channel_unref(channel);
+            shell_view_set_enabled(TRUE);
+            shell_status_set_enabled(TRUE);
+            gtk_widget_set_sensitive(
+                GTK_WIDGET(shell_get_main_shell()->transient_dialog), TRUE);
+            g_free(benchmark_dialog);
 
-          shell_status_update(_("Done."));
+            shell_status_update(_("Done."));
 
-          return;
-       }
+            return;
+        }
 
-       gtk_widget_destroy(bench_dialog);
-       g_free(benchmark_dialog);
-       shell_status_set_enabled(TRUE);
-       shell_status_update(_("Done."));
+        gtk_widget_destroy(bench_dialog);
+        g_free(benchmark_dialog);
+        shell_status_set_enabled(TRUE);
+        shell_status_update(_("Done."));
     }
 
     setpriority(PRIO_PROCESS, 0, -20);
@@ -564,79 +757,113 @@ static void do_benchmark(void (*benchmark_function)(void), int entry)
     setpriority(PRIO_PROCESS, 0, old_priority);
 }
 
-gchar *hi_module_get_name(void)
-{
-    return g_strdup(_("Benchmarks"));
-}
+gchar *hi_module_get_name(void) { return g_strdup(_("Benchmarks")); }
 
-guchar hi_module_get_weight(void)
-{
-    return 240;
-}
+guchar hi_module_get_weight(void) { return 240; }
 
-ModuleEntry *hi_module_get_entries(void)
-{
-    return entries;
-}
+ModuleEntry *hi_module_get_entries(void) { return entries; }
 
-ModuleAbout *hi_module_get_about(void)
+const ModuleAbout *hi_module_get_about(void)
 {
-    static ModuleAbout ma[] = {
-	{
-	 .author = "Leandro A. F. Pereira",
-	 .description = N_("Perform tasks and compare with other systems"),
-	 .version = VERSION,
-	 .license = "GNU GPL version 2"}
+    static const ModuleAbout ma = {
+        .author = "L. A. F. Pereira",
+        .description = N_("Perform tasks and compare with other systems"),
+        .version = VERSION,
+        .license = "GNU GPL version 2 or later.",
     };
 
-    return ma;
+    return &ma;
 }
 
-static gchar *get_benchmark_results()
+static gchar *get_benchmark_results(gsize *len)
 {
-    gint i;
-    void (*scan_callback) (gboolean rescan);
-
-    sending_benchmark_results = TRUE;
-
-    gchar *machine = module_call_method("devices::getProcessorName");
-    gchar *machineclock = module_call_method("devices::getProcessorFrequency");
-    gchar *machineram = module_call_method("devices::getMemoryTotal");
-    gchar *result = g_strdup_printf("[param]\n"
-				    "machine=%s\n"
-				    "machineclock=%s\n"
-				    "machineram=%s\n"
-				    "nbenchmarks=%zu\n",
-				    machine,
-				    machineclock,
-				    machineram,
-				    G_N_ELEMENTS(entries) - 1);
+    void (*scan_callback)(gboolean);
+    JsonBuilder *builder;
+    JsonGenerator *generator;
+    JsonNode *root;
+    bench_machine *this_machine;
+    gchar *out;
+    guint i;
+
     for (i = 0; i < G_N_ELEMENTS(entries); i++) {
-        scan_callback = entries[i].scan_callback;
-        if (!scan_callback)
+        if (!entries[i].name || !entries[i].scan_callback)
+            continue;
+        if (entries[i].flags & MODULE_FLAG_HIDE)
             continue;
 
+        scan_callback = entries[i].scan_callback;
+        if (scan_callback)
+            scan_callback(bench_results[i].result < 0.0);
+    }
+
+    this_machine = bench_machine_this();
+    builder = json_builder_new();
+    json_builder_begin_object(builder);
+    for (i = 0; i < G_N_ELEMENTS(entries); i++) {
+        if (!entries[i].name || entries[i].flags & MODULE_FLAG_HIDE)
+            continue;
         if (bench_results[i].result < 0.0) {
-           /* benchmark was cancelled */
-           scan_callback(TRUE);
-        } else {
-           scan_callback(FALSE);
+            /* Benchmark failed? */
+            continue;
         }
 
-        result = h_strdup_cprintf("[bench%d]\n"
-                                  "name=%s\n"
-                                  "value=%f\n",
-                                  result,
-                                  i, entries[i].name, bench_results[i]);
+        json_builder_set_member_name(builder, entries[i].name);
+
+        json_builder_begin_object(builder);
+
+#define ADD_JSON_VALUE(type, name, value)                                      \
+    do {                                                                       \
+        json_builder_set_member_name(builder, (name));                         \
+        json_builder_add_##type##_value(builder, (value));                     \
+    } while (0)
+
+        ADD_JSON_VALUE(string, "Board", this_machine->board);
+        ADD_JSON_VALUE(int, "MemoryInKiB", this_machine->memory_kiB);
+        ADD_JSON_VALUE(string, "CpuName", this_machine->cpu_name);
+        ADD_JSON_VALUE(string, "CpuDesc", this_machine->cpu_desc);
+        ADD_JSON_VALUE(string, "CpuConfig", this_machine->cpu_config);
+        ADD_JSON_VALUE(string, "CpuConfig", this_machine->cpu_config);
+        ADD_JSON_VALUE(string, "OpenGlRenderer", this_machine->ogl_renderer);
+        ADD_JSON_VALUE(string, "GpuDesc", this_machine->gpu_desc);
+        ADD_JSON_VALUE(int, "NumCpus", this_machine->processors);
+        ADD_JSON_VALUE(int, "NumCores", this_machine->cores);
+        ADD_JSON_VALUE(int, "NumNodes", this_machine->nodes);
+        ADD_JSON_VALUE(int, "NumThreads", this_machine->threads);
+        ADD_JSON_VALUE(string, "MachineId", this_machine->mid);
+        ADD_JSON_VALUE(int, "PointerBits", this_machine->ptr_bits);
+        ADD_JSON_VALUE(boolean, "DataFromSuperUser", this_machine->is_su_data);
+        ADD_JSON_VALUE(int, "PhysicalMemoryInMiB",
+                       this_machine->memory_phys_MiB);
+        ADD_JSON_VALUE(string, "MemoryTypes", this_machine->ram_types);
+        ADD_JSON_VALUE(int, "MachineDataVersion",
+                       this_machine->machine_data_version);
+        ADD_JSON_VALUE(string, "MachineType", this_machine->machine_type);
+
+        ADD_JSON_VALUE(boolean, "Legacy", FALSE);
+        ADD_JSON_VALUE(string, "ExtraInfo", bench_results[i].extra);
+        ADD_JSON_VALUE(string, "UserNote", bench_results[i].user_note);
+        ADD_JSON_VALUE(double, "BenchmarkResult", bench_results[i].result);
+        ADD_JSON_VALUE(double, "ElapsedTime", bench_results[i].elapsed_time);
+        ADD_JSON_VALUE(int, "UsedThreads", bench_results[i].threads_used);
+        ADD_JSON_VALUE(int, "BenchmarkVersion", bench_results[i].revision);
+
+#undef ADD_JSON_VALUE
+
+        json_builder_end_object(builder);
     }
+    json_builder_end_object(builder);
+
+    generator = json_generator_new();
+    json_generator_set_root(generator, json_builder_get_root(builder));
+    json_generator_set_pretty(generator, TRUE);
 
-    g_free(machine);
-    g_free(machineclock);
-    g_free(machineram);
+    out = json_generator_to_data(generator, len);
 
-    sending_benchmark_results = FALSE;
+    g_object_unref(generator);
+    g_object_unref(builder);
+    bench_machine_free(this_machine);
 
-    return result;
+    return out;
 }
 
 static gchar *run_benchmark(gchar *name)
@@ -646,42 +873,44 @@ static gchar *run_benchmark(gchar *name)
     DEBUG("name = %s", name);
 
     for (i = 0; entries[i].name; i++) {
-      if (g_str_equal(entries[i].name, name)) {
-        void (*scan_callback)(gboolean rescan);
-
-        if ((scan_callback = entries[i].scan_callback)) {
-          scan_callback(FALSE);
-
-#define CHK_RESULT_FORMAT(F) (params.result_format && strcmp(params.result_format, F) == 0)
-
-          if (params.run_benchmark) {
-            if (CHK_RESULT_FORMAT("conf") ) {
-               bench_result *b = bench_result_this_machine(name, bench_results[i]);
-               char *temp = bench_result_benchmarkconf_line(b);
-               bench_result_free(b);
-               return temp;
-            } else if (CHK_RESULT_FORMAT("shell") ) {
-               bench_result *b = bench_result_this_machine(name, bench_results[i]);
-               char *temp = bench_result_more_info_complete(b);
-               bench_result_free(b);
-               return temp;
+        if (g_str_equal(entries[i].name, name)) {
+            void (*scan_callback)(gboolean rescan);
+
+            if ((scan_callback = entries[i].scan_callback)) {
+                scan_callback(FALSE);
+
+#define CHK_RESULT_FORMAT(F)                                                   \
+    (params.result_format && strcmp(params.result_format, F) == 0)
+
+                if (params.run_benchmark) {
+                    /* attach the user note */
+                    if (params.bench_user_note)
+                        strncpy(bench_results[i].user_note,
+                                params.bench_user_note, 255);
+
+                    if (CHK_RESULT_FORMAT("shell")) {
+                        bench_result *b =
+                            bench_result_this_machine(name, bench_results[i]);
+                        char *temp = bench_result_more_info_complete(b);
+                        bench_result_free(b);
+                        return temp;
+                    }
+                    /* defaults to "short" which is below */
+                }
+
+                return bench_value_to_str(bench_results[i]);
             }
-            /* defaults to "short" which is below*/
-          }
-
-          return bench_value_to_str(bench_results[i]);
         }
-      }
     }
 
     return NULL;
 }
 
-ShellModuleMethod *hi_exported_methods(void)
+const ShellModuleMethod *hi_exported_methods(void)
 {
-    static ShellModuleMethod m[] = {
+    static const ShellModuleMethod m[] = {
         {"runBenchmark", run_benchmark},
-        {NULL}
+        {NULL},
     };
 
     return m;
@@ -690,31 +919,28 @@ ShellModuleMethod *hi_exported_methods(void)
 void hi_module_init(void)
 {
     static SyncEntry se[] = {
-	{
-	 .fancy_name = N_("Send benchmark results"),
-	 .name = "SendBenchmarkResults",
-	 .save_to = NULL,
-	 .get_data = get_benchmark_results},
-	{
-	 .fancy_name = N_("Receive benchmark results"),
-	 .name = "RecvBenchmarkResults",
-	 .save_to = "benchmark.conf",
-	 .get_data = NULL}
+        {
+            .name = N_("Send benchmark results"),
+            .file_name = "benchmark.json",
+            .generate_contents_for_upload = get_benchmark_results,
+        },
+        {
+            .name = N_("Receive benchmark results"),
+            .file_name = "benchmark.json",
+        },
     };
 
     sync_manager_add_entry(&se[0]);
     sync_manager_add_entry(&se[1]);
 
-    bench_value er = EMPTY_BENCH_VALUE;
-    int i;
-    for (i = 0; i < G_N_ELEMENTS(entries) - 1; i++) {
-         bench_results[i] = er;
-    }
+    guint i;
+    for (i = 0; i < G_N_ELEMENTS(entries) - 1 /* account for NULL */; i++)
+        bench_results[i] = (bench_value)EMPTY_BENCH_VALUE;
 }
 
 gchar **hi_module_get_dependencies(void)
 {
-    static gchar *deps[] = { "devices.so", NULL };
+    static gchar *deps[] = {"devices.so", NULL};
 
     return deps;
 }