aboutsummaryrefslogtreecommitdiff
path: root/modules/benchmark
diff options
context:
space:
mode:
Diffstat (limited to 'modules/benchmark')
-rw-r--r--modules/benchmark/bench_results.c605
-rw-r--r--modules/benchmark/bench_util.c58
-rw-r--r--modules/benchmark/benches.c254
-rw-r--r--modules/benchmark/blowfish.c493
-rw-r--r--modules/benchmark/blowfish2.c83
-rw-r--r--modules/benchmark/cryptohash.c89
-rw-r--r--modules/benchmark/drawing.c33
-rw-r--r--modules/benchmark/fbench.c747
-rw-r--r--modules/benchmark/fft.c70
-rw-r--r--modules/benchmark/fftbench.c212
-rw-r--r--modules/benchmark/fib.c61
-rw-r--r--modules/benchmark/guibench.c353
-rw-r--r--modules/benchmark/md5.c317
-rw-r--r--modules/benchmark/nqueens.c68
-rw-r--r--modules/benchmark/raytrace.c56
-rw-r--r--modules/benchmark/sha1.c329
-rw-r--r--modules/benchmark/sysbench.c270
-rw-r--r--modules/benchmark/zlib.c88
18 files changed, 4186 insertions, 0 deletions
diff --git a/modules/benchmark/bench_results.c b/modules/benchmark/bench_results.c
new file mode 100644
index 00000000..18ed0739
--- /dev/null
+++ b/modules/benchmark/bench_results.c
@@ -0,0 +1,605 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2020 L. A. F. Pereira <l@tia.mat.br>
+ * This file:
+ * Copyright (C) 2017 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 or later.
+ *
+ * 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 <stdlib.h>
+#include <locale.h>
+#include <inttypes.h>
+#include <json-glib/json-glib.h>
+#include "nice_name.h"
+
+/* in dmi_memory.c */
+uint64_t memory_devices_get_system_memory_MiB();
+gchar *memory_devices_get_system_memory_types_str();
+
+/*/ Used for an unknown value. Having it in only one place cleans up the .po
+ * line references */
+static const char *unk = N_("(Unknown)");
+
+typedef struct {
+ char *board;
+ uint64_t memory_kiB; /* from /proc/meminfo -> MemTotal */
+ char *cpu_name;
+ char *cpu_desc;
+ char *cpu_config;
+ char *ogl_renderer;
+ char *gpu_desc;
+ int processors;
+ int cores;
+ int threads;
+ int nodes;
+ char *mid;
+ int ptr_bits; /* 32, 64... BENCH_PTR_BITS; 0 for unspecified */
+ int is_su_data; /* 1 = data collected as root */
+ uint64_t memory_phys_MiB; /* from DMI/SPD/DTree/Table/Blocks, etc. */
+ char *ram_types;
+ int machine_data_version;
+ char *machine_type;
+} bench_machine;
+
+typedef struct {
+ char *name;
+ bench_value bvalue;
+ bench_machine *machine;
+ int legacy; /* an old benchmark.conf result */
+} bench_result;
+
+static char *cpu_config_retranslate(char *str, int force_en, int replacing)
+{
+ char *new_str = NULL;
+ char *mhz = (force_en) ? "MHz" : _("MHz");
+ char *c = str, *tmp;
+ int t;
+ float f;
+
+ if (str != NULL) {
+ new_str = strdup("");
+ if (strchr(str, 'x')) {
+ while (c != NULL && (sscanf(c, "%dx %f", &t, &f)==2)) {
+ tmp = g_strdup_printf("%s%s%dx %.2f %s", new_str,
+ strlen(new_str) ? " + " : "", t, f, mhz);
+ free(new_str);
+ new_str = tmp;
+ c = strchr(c + 1, '+');
+ if (c)
+ c++; /* move past the + */
+ }
+ } else {
+ sscanf(c, "%f", &f);
+ tmp = g_strdup_printf("%s%s%dx %.2f %s", new_str,
+ strlen(new_str) ? " + " : "", 1, f, mhz);
+ free(new_str);
+ new_str = tmp;
+ }
+
+ if (replacing)
+ free(str);
+ }
+
+ return new_str;
+}
+
+/* "2x 1400.00 MHz + 2x 800.00 MHz" -> 4400.0 */
+static float cpu_config_val(char *str)
+{
+ char *c = str;
+ int t;
+ float f, r = 0.0;
+ if (str != NULL) {
+ if (strchr(str, 'x')) {
+ while (c != NULL && (sscanf(c, "%dx %f", &t, &f)==2)) {
+ r += f * t;
+ c = strchr(c + 1, '+');
+ if (c)
+ c++; /* move past the + */
+ }
+ } else {
+ sscanf(c, "%f", &r);
+ }
+ }
+ return r;
+}
+
+static int cpu_config_cmp(char *str0, char *str1)
+{
+ float r0, r1;
+ r0 = cpu_config_val(str0);
+ r1 = cpu_config_val(str1);
+ if (r0 == r1)
+ return 0;
+ if (r0 < r1)
+ return -1;
+ return 1;
+}
+
+static int cpu_config_is_close(char *str0, char *str1)
+{
+ float r0, r1, r1n;
+ r0 = cpu_config_val(str0);
+ r1 = cpu_config_val(str1);
+ r1n = r1 * .9;
+ if (r0 > r1n && r0 < r1)
+ return 1;
+ return 0;
+}
+
+static void gen_machine_id(bench_machine *m)
+{
+ char *s;
+
+ if (m) {
+ if (m->mid != NULL)
+ free(m->mid);
+
+ /* Don't try and translate unknown. The mid string needs to be made of
+ * all untranslated elements.*/
+ m->mid = g_strdup_printf("%s;%s;%.2f",
+ (m->board != NULL) ? m->board : "(Unknown)",
+ m->cpu_name, cpu_config_val(m->cpu_config));
+ for (s = m->mid; *s; s++) {
+ if (!isalnum(*s) && *s != '(' && *s != ')' && *s != ';')
+ *s = '_';
+ }
+ }
+}
+
+bench_machine *bench_machine_new()
+{
+ return calloc(1, sizeof(bench_machine));
+}
+
+bench_machine *bench_machine_this()
+{
+ bench_machine *m = NULL;
+ char *tmp;
+
+ m = bench_machine_new();
+ if (m) {
+ m->ptr_bits = BENCH_PTR_BITS;
+ m->is_su_data = (getuid() == 0);
+ m->board = module_call_method("devices::getMotherboard");
+ m->cpu_name = module_call_method("devices::getProcessorName");
+ m->cpu_desc = module_call_method("devices::getProcessorDesc");
+ m->cpu_config =
+ module_call_method("devices::getProcessorFrequencyDesc");
+ m->gpu_desc = module_call_method("devices::getGPUList");
+ m->ogl_renderer = module_call_method("computer::getOGLRenderer");
+ tmp = module_call_method("computer::getMemoryTotal");
+ m->memory_kiB = strtoull(tmp, NULL, 10);
+ m->memory_phys_MiB = memory_devices_get_system_memory_MiB();
+ m->ram_types = memory_devices_get_system_memory_types_str();
+ m->machine_type = module_call_method("computer::getMachineType");
+ free(tmp);
+
+ cpu_procs_cores_threads_nodes(&m->processors, &m->cores, &m->threads, &m->nodes);
+ gen_machine_id(m);
+ }
+ return m;
+}
+
+void bench_machine_free(bench_machine *s)
+{
+ if (s) {
+ free(s->board);
+ free(s->cpu_name);
+ free(s->cpu_desc);
+ free(s->cpu_config);
+ free(s->mid);
+ free(s->ram_types);
+ free(s->machine_type);
+ free(s);
+ }
+}
+
+void bench_result_free(bench_result *s)
+{
+ if (s) {
+ free(s->name);
+ bench_machine_free(s->machine);
+ g_free(s);
+ }
+}
+
+bench_result *bench_result_this_machine(const char *bench_name, bench_value r)
+{
+ bench_result *b = NULL;
+
+ b = malloc(sizeof(bench_result));
+ if (b) {
+ memset(b, 0, sizeof(bench_result));
+ b->machine = bench_machine_this();
+ b->name = strdup(bench_name);
+ b->bvalue = r;
+ b->legacy = 0;
+ }
+ return b;
+}
+
+/* -1 for none */
+static int nx_prefix(const char *str)
+{
+ char *s, *x;
+ if (str != NULL) {
+ s = (char *)str;
+ x = strchr(str, 'x');
+ if (x && x - s >= 1) {
+ while (s != x) {
+ if (!isdigit(*s))
+ return -1;
+ s++;
+ }
+ *x = 0;
+ return atoi(str);
+ }
+ }
+ return -1;
+}
+
+/* old results didn't store the actual number of threads used */
+static int guess_threads_old_result(const char *bench_name,
+ int threads_available)
+{
+#define CHKBNAME(BN) (strcmp(bench_name, BN) == 0)
+ if (CHKBNAME("CPU Fibonacci"))
+ return 1;
+ if (CHKBNAME("FPU FFT")) {
+ if (threads_available >= 4)
+ return 4;
+ else if (threads_available >= 2)
+ return 2;
+ else
+ return 1;
+ }
+ if (CHKBNAME("CPU N-Queens")) {
+ if (threads_available >= 10)
+ return 10;
+ else if (threads_available >= 5)
+ return 5;
+ else if (threads_available >= 2)
+ return 2;
+ else
+ return 1;
+ }
+ return threads_available;
+}
+
+static gboolean cpu_name_needs_cleanup(const char *cpu_name)
+{
+ return strstr(cpu_name, "Intel") || strstr(cpu_name, "AMD") ||
+ strstr(cpu_name, "VIA") || strstr(cpu_name, "Cyrix");
+}
+
+static void filter_invalid_chars(gchar *str)
+{
+ gchar *p;
+
+ for (p = str; *p; p++) {
+ if (*p == '\n' || *p == ';' || *p == '|')
+ *p = '_';
+ }
+}
+
+static gboolean json_get_boolean(JsonObject *obj, const gchar *key)
+{
+ if (!json_object_has_member(obj, key))
+ return FALSE;
+ return json_object_get_boolean_member(obj, key);
+}
+
+static double json_get_double(JsonObject *obj, const gchar *key)
+{
+ if (!json_object_has_member(obj, key))
+ return 0;
+ return json_object_get_double_member(obj, key);
+}
+
+static int json_get_int(JsonObject *obj, const gchar *key)
+{
+ if (!json_object_has_member(obj, key))
+ return 0;
+ return json_object_get_int_member(obj, key);
+}
+
+static const gchar *json_get_string(JsonObject *obj, const gchar *key)
+{
+ if (!json_object_has_member(obj, key))
+ return "";
+ return json_object_get_string_member(obj, key);
+}
+
+static gchar *json_get_string_dup(JsonObject *obj, const gchar *key)
+{
+ return g_strdup(json_get_string(obj, key));
+}
+
+static double parse_frequency(const char *freq)
+{
+ static locale_t locale;
+
+ if (!locale)
+ locale = newlocale(LC_NUMERIC_MASK, "C", NULL);
+
+ return strtod_l(freq, NULL, locale);
+}
+
+static void append_cpu_config(JsonObject *object,
+ const gchar *member_name,
+ JsonNode *member_node,
+ gpointer user_data)
+{
+ GString *output = user_data;
+
+ if (output->len)
+ g_string_append(output, ", ");
+
+ g_string_append_printf(output, "%ldx %.2f %s", (long int)json_node_get_int(member_node),
+ parse_frequency(member_name), _("MHz"));
+}
+
+static gchar *get_cpu_config(JsonObject *machine)
+{
+ JsonObject *cpu_config_map =
+ json_object_get_object_member(machine, "CpuConfigMap");
+
+ if (!cpu_config_map)
+ return json_get_string_dup(machine, "CpuConfig");
+
+ GString *output = g_string_new(NULL);
+ json_object_foreach_member(cpu_config_map, append_cpu_config, output);
+ return g_string_free(output, FALSE);
+}
+
+static gchar *get_cpu_desc(JsonObject *machine)
+{
+ int num_cpus = json_get_int(machine, "NumCpus");
+
+ if (!num_cpus)
+ return json_get_string_dup(machine, "CpuDesc");
+
+ /* FIXME: This is adapted from processor_describe_default() in
+ * devices.c! */
+
+ int num_cores = json_get_int(machine, "NumCores");
+ int num_threads = json_get_int(machine, "NumThreads");
+ int num_nodes = json_get_int(machine, "NumNodes");
+ const char *packs_fmt =
+ ngettext("%d physical processor", "%d physical processors", num_cpus);
+ const char *cores_fmt = ngettext("%d core", "%d cores", num_cores);
+ const char *threads_fmt = ngettext("%d thread", "%d threads", num_threads);
+ char *full_fmt, *ret;
+
+ if (num_nodes > 1) {
+ const char *nodes_fmt =
+ ngettext("%d NUMA node", "%d NUMA nodes", num_nodes);
+
+ full_fmt = g_strdup_printf(
+ _(/*/NP procs; NC cores across NN nodes; NT threads*/
+ "%s; %s across %s; %s"),
+ packs_fmt, cores_fmt, nodes_fmt, threads_fmt);
+ ret = g_strdup_printf(full_fmt, num_cpus, num_cores * num_nodes, num_nodes, num_threads);
+ } else {
+ full_fmt =
+ g_strdup_printf(_(/*/NP procs; NC cores; NT threads*/ "%s; %s; %s"),
+ packs_fmt, cores_fmt, threads_fmt);
+ ret = g_strdup_printf(full_fmt, num_cpus, num_cores, num_threads);
+ }
+
+ free(full_fmt);
+ return ret;
+}
+
+bench_result *bench_result_benchmarkjson(const gchar *bench_name,
+ JsonNode *node)
+{
+ JsonObject *machine;
+ bench_result *b;
+ gchar *p;
+
+ if (json_node_get_node_type(node) != JSON_NODE_OBJECT)
+ return NULL;
+
+ machine = json_node_get_object(node);
+
+ b = g_new0(bench_result, 1);
+ b->name = g_strdup(bench_name);
+ b->legacy = json_get_boolean(machine, "Legacy");
+
+ b->bvalue = (bench_value){
+ .result = json_get_double(machine, "BenchmarkResult"),
+ .elapsed_time = json_get_double(machine, "ElapsedTime"),
+ .threads_used = json_get_int(machine, "UsedThreads"),
+ .revision = json_get_int(machine, "BenchmarkRevision"),
+ };
+
+ snprintf(b->bvalue.extra, sizeof(b->bvalue.extra), "%s",
+ json_get_string(machine, "ExtraInfo"));
+ filter_invalid_chars(b->bvalue.extra);
+
+ snprintf(b->bvalue.user_note, sizeof(b->bvalue.user_note), "%s",
+ json_get_string(machine, "UserNote"));
+ filter_invalid_chars(b->bvalue.user_note);
+
+ int nodes = json_get_int(machine, "NumNodes");
+
+ if (nodes == 0)
+ nodes = 1;
+
+ b->machine = bench_machine_new();
+ *b->machine = (bench_machine){
+ .board = json_get_string_dup(machine, "Board"),
+ .memory_kiB = json_get_int(machine, "MemoryInKiB"),
+ .cpu_name = json_get_string_dup(machine, "CpuName"),
+ .cpu_desc = get_cpu_desc(machine),
+ .cpu_config = get_cpu_config(machine),
+ .ogl_renderer = json_get_string_dup(machine, "OpenGlRenderer"),
+ .gpu_desc = json_get_string_dup(machine, "GpuDesc"),
+ .processors = json_get_int(machine, "NumCpus"),
+ .cores = json_get_int(machine, "NumCores"),
+ .threads = json_get_int(machine, "NumThreads"),
+ .nodes = nodes,
+ .mid = json_get_string_dup(machine, "MachineId"),
+ .ptr_bits = json_get_int(machine, "PointerBits"),
+ .is_su_data = json_get_boolean(machine, "DataFromSuperUser"),
+ .memory_phys_MiB = json_get_int(machine, "PhysicalMemoryInMiB"),
+ .ram_types = json_get_string_dup(machine, "MemoryTypes"),
+ .machine_data_version = json_get_int(machine, "MachineDataVersion"),
+ .machine_type = json_get_string_dup(machine, "MachineType"),
+ };
+
+ return b;
+}
+
+static char *bench_result_more_info_less(bench_result *b)
+{
+ char *memory = NULL;
+ if (b->machine->memory_phys_MiB) {
+ memory =
+ g_strdup_printf("%" PRId64 " %s %s", b->machine->memory_phys_MiB,
+ _("MiB"), b->machine->ram_types);
+ } else {
+ memory =
+ (b->machine->memory_kiB > 0)
+ ? g_strdup_printf("%" PRId64 " %s %s", b->machine->memory_kiB,
+ _("kiB"), problem_marker())
+ : g_strdup(_(unk));
+ }
+ char bench_str[256] = "";
+ if (b->bvalue.revision >= 0)
+ snprintf(bench_str, 127, "%d", b->bvalue.revision);
+ char bits[24] = "";
+ if (b->machine->ptr_bits)
+ snprintf(bits, 23, _("%d-bit"), b->machine->ptr_bits);
+
+ char *ret = g_strdup_printf(
+ "[%s]\n"
+ /* threads */ "%s=%d\n"
+ /* elapsed */ "%s=%0.4f %s\n"
+ "%s=%s\n"
+ "%s=%s\n"
+ "%s=%s\n"
+ /* legacy */ "%s%s=%s\n"
+ "[%s]\n"
+ /* board */ "%s=%s\n"
+ /* machine_type */ "%s=%s\n"
+ /* cpu */ "%s=%s\n"
+ /* cpudesc */ "%s=%s\n"
+ /* cpucfg */ "%s=%s\n"
+ /* threads */ "%s=%d\n"
+ /* gpu desc */ "%s=%s\n"
+ /* ogl rend */ "%s=%s\n"
+ /* mem */ "%s=%s\n"
+ /* bits */ "%s=%s\n",
+ _("Benchmark Result"), _("Threads"), b->bvalue.threads_used,
+ _("Elapsed Time"), b->bvalue.elapsed_time, _("seconds"),
+ *bench_str ? _("Revision") : "#Revision", bench_str,
+ *b->bvalue.extra ? _("Extra Information") : "#Extra", b->bvalue.extra,
+ *b->bvalue.user_note ? _("User Note") : "#User Note",
+ b->bvalue.user_note, b->legacy ? problem_marker() : "",
+ b->legacy ? _("Note") : "#Note",
+ b->legacy ? _("This result is from an old version of HardInfo. Results "
+ "might not be comparable to current version. Some "
+ "details are missing.")
+ : "",
+ _("Machine"),
+ _("Board"), (b->machine->board != NULL) ? b->machine->board : _(unk),
+ _("Machine Type"), (b->machine->machine_type != NULL) ? b->machine->machine_type : _(unk),
+ _("CPU Name"), b->machine->cpu_name,
+ _("CPU Description"), (b->machine->cpu_desc != NULL) ? b->machine->cpu_desc : _(unk),
+ _("CPU Config"), b->machine->cpu_config,
+ _("Threads Available"), b->machine->threads,
+ _("GPU"), (b->machine->gpu_desc != NULL) ? b->machine->gpu_desc : _(unk),
+ _("OpenGL Renderer"), (b->machine->ogl_renderer != NULL) ? b->machine->ogl_renderer : _(unk),
+ _("Memory"), memory,
+ b->machine->ptr_bits ? _("Pointer Size") : "#AddySize", bits);
+ free(memory);
+ return ret;
+}
+
+static char *bench_result_more_info_complete(bench_result *b)
+{
+ char bench_str[256] = "";
+ strncpy(bench_str, b->name, 127);
+ if (b->bvalue.revision >= 0)
+ snprintf(bench_str + strlen(bench_str), 127, " (r%d)",
+ b->bvalue.revision);
+ char bits[24] = "";
+ if (b->machine->ptr_bits)
+ snprintf(bits, 23, _("%d-bit"), b->machine->ptr_bits);
+
+ return g_strdup_printf(
+ "[%s]\n"
+ /* bench name */ "%s=%s\n"
+ /* threads */ "%s=%d\n"
+ /* result */ "%s=%0.2f\n"
+ /* elapsed */ "%s=%0.4f %s\n"
+ "%s=%s\n"
+ "%s=%s\n"
+ /* legacy */ "%s%s=%s\n"
+ "[%s]\n"
+ /* board */ "%s=%s\n"
+ /* machine_type */ "%s=%s\n"
+ /* cpu */ "%s=%s\n"
+ /* cpudesc */ "%s=%s\n"
+ /* cpucfg */ "%s=%s\n"
+ /* threads */ "%s=%d\n"
+ /* gpu desc */ "%s=%s\n"
+ /* ogl rend */ "%s=%s\n"
+ /* mem */ "%s=%" PRId64 " %s\n"
+ /* mem phys */ "%s=%" PRId64 " %s %s\n"
+ /* bits */ "%s=%s\n"
+ "%s=%d\n"
+ "%s=%d\n"
+ "[%s]\n"
+ /* mid */ "%s=%s\n"
+ /* cfg_val */ "%s=%.2f\n",
+ _("Benchmark Result"), _("Benchmark"), bench_str, _("Threads"),
+ b->bvalue.threads_used, _("Result"), b->bvalue.result,
+ _("Elapsed Time"), b->bvalue.elapsed_time, _("seconds"),
+ *b->bvalue.extra ? _("Extra Information") : "#Extra", b->bvalue.extra,
+ *b->bvalue.user_note ? _("User Note") : "#User Note",
+ b->bvalue.user_note, b->legacy ? problem_marker() : "",
+ b->legacy ? _("Note") : "#Note",
+ b->legacy ? _("This result is from an old version of HardInfo. Results "
+ "might not be comparable to current version. Some "
+ "details are missing.")
+ : "",
+ _("Machine"), _("Board"),
+ (b->machine->board != NULL) ? b->machine->board : _(unk),
+ _("Machine Type"), (b->machine->machine_type != NULL) ? b->machine->machine_type : _(unk),
+ _("CPU Name"),
+ b->machine->cpu_name, _("CPU Description"),
+ (b->machine->cpu_desc != NULL) ? b->machine->cpu_desc : _(unk),
+ _("CPU Config"), b->machine->cpu_config, _("Threads Available"),
+ b->machine->threads, _("GPU"),
+ (b->machine->gpu_desc != NULL) ? b->machine->gpu_desc : _(unk),
+ _("OpenGL Renderer"),
+ (b->machine->ogl_renderer != NULL) ? b->machine->ogl_renderer : _(unk),
+ _("Memory"), b->machine->memory_kiB, _("kiB"), _("Physical Memory"),
+ b->machine->memory_phys_MiB, _("MiB"), b->machine->ram_types,
+ b->machine->ptr_bits ? _("Pointer Size") : "#AddySize", bits,
+ ".machine_data_version", b->machine->machine_data_version,
+ ".is_su_data", b->machine->is_su_data, _("Handles"), _("mid"),
+ b->machine->mid, _("cfg_val"), cpu_config_val(b->machine->cpu_config));
+}
+
+char *bench_result_more_info(bench_result *b)
+{
+ // return bench_result_more_info_complete(b);
+ return bench_result_more_info_less(b);
+}
diff --git a/modules/benchmark/bench_util.c b/modules/benchmark/bench_util.c
new file mode 100644
index 00000000..d9e5bc55
--- /dev/null
+++ b/modules/benchmark/bench_util.c
@@ -0,0 +1,58 @@
+
+#include "benchmark.h"
+#include "md5.h"
+
+gchar *get_test_data(gsize min_size) {
+ gchar *bdata_path, *data;
+ gsize data_size;
+
+ gchar *exp_data, *p;
+ gsize sz;
+
+ bdata_path = g_build_filename(params.path_data, "benchmark.data", NULL);
+ if (!g_file_get_contents(bdata_path, &data, &data_size, NULL)) {
+ g_free(bdata_path);
+ return NULL;
+ }
+
+ if (data_size < min_size) {
+ DEBUG("expanding %lu bytes of test data to %lu bytes", data_size, min_size);
+ exp_data = g_malloc(min_size + 1);
+ memcpy(exp_data, data, data_size);
+ p = exp_data + data_size;
+ sz = data_size;
+ while (sz < (min_size - data_size) ) {
+ memcpy(p, data, data_size);
+ p += data_size;
+ sz += data_size;
+ }
+ strncpy(p, data, min_size - sz);
+ g_free(data);
+ data = exp_data;
+ }
+ g_free(bdata_path);
+
+ return data;
+}
+
+char *digest_to_str(const char *digest, int len) {
+ int max = len * 2;
+ char *ret = malloc(max+1);
+ char *p = ret;
+ memset(ret, 0, max+1);
+ int i = 0;
+ for(; i < len; i++) {
+ unsigned char byte = digest[i];
+ p += sprintf(p, "%02x", byte);
+ }
+ return ret;
+}
+
+char *md5_digest_str(const char *data, unsigned int len) {
+ struct MD5Context ctx;
+ guchar digest[16];
+ MD5Init(&ctx);
+ MD5Update(&ctx, (guchar *)data, len);
+ MD5Final(digest, &ctx);
+ return digest_to_str(digest, 16);
+}
diff --git a/modules/benchmark/benches.c b/modules/benchmark/benches.c
new file mode 100644
index 00000000..c621d695
--- /dev/null
+++ b/modules/benchmark/benches.c
@@ -0,0 +1,254 @@
+/*
+ * HardInfo - System Information and Benchmark
+ * Copyright (C) 2003-2017 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 or later.
+ *
+ * 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
+ */
+
+/* These are parts of modules/benchmark.c where specific benchmarks are defined. */
+
+#define BENCH_CALLBACK(CN, BN, BID, R) \
+gchar *CN() { \
+ if (R) \
+ return benchmark_include_results_reverse(bench_results[BID], BN); \
+ else \
+ return benchmark_include_results(bench_results[BID], BN); \
+}
+
+#define BENCH_SCAN_SIMPLE(SN, BF, BID) \
+void SN(gboolean reload) { \
+ SCAN_START(); \
+ do_benchmark(BF, BID); \
+ SCAN_END(); \
+}
+
+#define BENCH_SIMPLE(BID, BN, BF, R) \
+ BENCH_CALLBACK(callback_##BF, BN, BID, R); \
+ BENCH_SCAN_SIMPLE(scan_##BF, BF, BID);
+
+// ID, NAME, FUNCTION, R (0 = lower is better, 1 = higher is better)
+BENCH_SIMPLE(BENCHMARK_FIB, "CPU Fibonacci", benchmark_fib, 1);
+BENCH_SIMPLE(BENCHMARK_NQUEENS, "CPU N-Queens", benchmark_nqueens, 1);
+BENCH_SIMPLE(BENCHMARK_FFT, "FPU FFT", benchmark_fft, 1);
+BENCH_SIMPLE(BENCHMARK_RAYTRACE, "FPU Raytracing (Single-thread)", benchmark_raytrace, 1);
+BENCH_SIMPLE(BENCHMARK_BLOWFISH_SINGLE, "CPU Blowfish (Single-thread)", benchmark_bfish_single, 1);
+BENCH_SIMPLE(BENCHMARK_BLOWFISH_THREADS, "CPU Blowfish (Multi-thread)", benchmark_bfish_threads, 1);
+BENCH_SIMPLE(BENCHMARK_BLOWFISH_CORES, "CPU Blowfish (Multi-core)", benchmark_bfish_cores, 1);
+BENCH_SIMPLE(BENCHMARK_ZLIB, "CPU Zlib", benchmark_zlib, 1);
+BENCH_SIMPLE(BENCHMARK_CRYPTOHASH, "CPU CryptoHash", benchmark_cryptohash, 1);
+BENCH_SIMPLE(BENCHMARK_SBCPU_SINGLE, "SysBench CPU (Single-thread)", benchmark_sbcpu_single, 1);
+BENCH_SIMPLE(BENCHMARK_SBCPU_ALL, "SysBench CPU (Multi-thread)", benchmark_sbcpu_all, 1);
+BENCH_SIMPLE(BENCHMARK_SBCPU_QUAD, "SysBench CPU (Four threads)", benchmark_sbcpu_quad, 1);
+BENCH_SIMPLE(BENCHMARK_MEMORY_SINGLE, "SysBench Memory (Single-thread)", benchmark_memory_single, 1);
+BENCH_SIMPLE(BENCHMARK_MEMORY_DUAL, "SysBench Memory (Two threads)", benchmark_memory_dual, 1);
+BENCH_SIMPLE(BENCHMARK_MEMORY_QUAD, "SysBench Memory (Quad threads)", benchmark_memory_quad, 1);
+BENCH_SIMPLE(BENCHMARK_MEMORY_ALL, "SysBench Memory (Multi-thread)", benchmark_memory_all, 1);
+
+#if !GTK_CHECK_VERSION(3,0,0)
+BENCH_CALLBACK(callback_gui, "GPU Drawing", BENCHMARK_GUI, 1);
+void scan_gui(gboolean reload)
+{
+ SCAN_START();
+
+ bench_value er = EMPTY_BENCH_VALUE;
+
+ if (params.run_benchmark) {
+ int argc = 0;
+
+ ui_init(&argc, NULL);
+ }
+
+ if (params.gui_running || params.run_benchmark) {
+ do_benchmark(benchmark_gui, BENCHMARK_GUI);
+ } else {
+ bench_results[BENCHMARK_GUI] = er;
+ }
+ SCAN_END();
+}
+#endif
+
+static ModuleEntry entries[] = {
+ [BENCHMARK_BLOWFISH_SINGLE] =
+ {
+ N_("CPU Blowfish (Single-thread)"),
+ "blowfish.png",
+ callback_benchmark_bfish_single,
+ scan_benchmark_bfish_single,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_BLOWFISH_THREADS] =
+ {
+ N_("CPU Blowfish (Multi-thread)"),
+ "blowfish.png",
+ callback_benchmark_bfish_threads,
+ scan_benchmark_bfish_threads,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_BLOWFISH_CORES] =
+ {
+ N_("CPU Blowfish (Multi-core)"),
+ "blowfish.png",
+ callback_benchmark_bfish_cores,
+ scan_benchmark_bfish_cores,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_ZLIB] =
+ {
+ N_("CPU Zlib"),
+ "file-roller.png",
+ callback_benchmark_zlib,
+ scan_benchmark_zlib,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_CRYPTOHASH] =
+ {
+ N_("CPU CryptoHash"),
+ "cryptohash.png",
+ callback_benchmark_cryptohash,
+ scan_benchmark_cryptohash,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_FIB] =
+ {
+ N_("CPU Fibonacci"),
+ "nautilus.png",
+ callback_benchmark_fib,
+ scan_benchmark_fib,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_NQUEENS] =
+ {
+ N_("CPU N-Queens"),
+ "nqueens.png",
+ callback_benchmark_nqueens,
+ scan_benchmark_nqueens,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_FFT] =
+ {
+ N_("FPU FFT"),
+ "fft.png",
+ callback_benchmark_fft,
+ scan_benchmark_fft,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_RAYTRACE] =
+ {
+ N_("FPU Raytracing (Single-thread)"),
+ "raytrace.png",
+ callback_benchmark_raytrace,
+ scan_benchmark_raytrace,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_SBCPU_SINGLE] =
+ {
+ N_("SysBench CPU (Single-thread)"),
+ "processor.png",
+ callback_benchmark_sbcpu_single,
+ scan_benchmark_sbcpu_single,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_SBCPU_ALL] =
+ {
+ N_("SysBench CPU (Multi-thread)"),
+ "processor.png",
+ callback_benchmark_sbcpu_all,
+ scan_benchmark_sbcpu_all,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_SBCPU_QUAD] =
+ {
+ N_("SysBench CPU (Four threads)"),
+ "processor.png",
+ callback_benchmark_sbcpu_quad,
+ scan_benchmark_sbcpu_quad,
+ MODULE_FLAG_HIDE,
+ },
+ [BENCHMARK_MEMORY_SINGLE] =
+ {
+ N_("SysBench Memory (Single-thread)"),
+ "memory.png",
+ callback_benchmark_memory_single,
+ scan_benchmark_memory_single,
+ MODULE_FLAG_NONE,
+ },
+ [BENCHMARK_MEMORY_DUAL] =
+ {
+ N_("SysBench Memory (Two threads)"),
+ "memory.png",
+ callback_benchmark_memory_dual,
+ scan_benchmark_memory_dual,
+ MODULE_FLAG_HIDE,
+ },
+ [BENCHMARK_MEMORY_QUAD] =
+ {
+ N_("SysBench Memory (Quad threads)"),
+ "memory.png",
+ callback_benchmark_memory_quad,
+ scan_benchmark_memory_quad,
+ MODULE_FLAG_HIDE,
+ },
+ [BENCHMARK_MEMORY_ALL] =
+ {
+ N_("SysBench Memory (Multi-thread)"),
+ "memory.png",
+ callback_benchmark_memory_all,
+ scan_benchmark_memory_all,
+ MODULE_FLAG_NONE,
+ },
+#if !GTK_CHECK_VERSION(3, 0, 0)
+ [BENCHMARK_GUI] =
+ {
+ N_("GPU Drawing"),
+ "module.png",
+ callback_gui,
+ scan_gui,
+ MODULE_FLAG_NO_REMOTE | MODULE_FLAG_HIDE,
+ },
+#else
+ [BENCHMARK_GUI] = {"#"},
+#endif
+ {NULL}};
+
+const gchar *hi_note_func(gint entry)
+{
+ switch (entry) {
+ case BENCHMARK_SBCPU_SINGLE:
+ case BENCHMARK_SBCPU_QUAD:
+ case BENCHMARK_SBCPU_ALL:
+ return _("Alexey Kopytov's <i><b>sysbench</b></i> is required.\n"
+ "Results in events/second. Higher is better.");
+
+ case BENCHMARK_MEMORY_SINGLE:
+ case BENCHMARK_MEMORY_DUAL:
+ case BENCHMARK_MEMORY_QUAD:
+ case BENCHMARK_MEMORY_ALL:
+ return _("Alexey Kopytov's <i><b>sysbench</b></i> is required.\n"
+ "Results in MiB/second. Higher is better.");
+
+ case BENCHMARK_CRYPTOHASH:
+ case BENCHMARK_BLOWFISH_SINGLE:
+ case BENCHMARK_BLOWFISH_THREADS:
+ case BENCHMARK_BLOWFISH_CORES:
+ case BENCHMARK_ZLIB:
+ case BENCHMARK_GUI:
+ case BENCHMARK_FFT:
+ case BENCHMARK_RAYTRACE:
+ case BENCHMARK_FIB:
+ case BENCHMARK_NQUEENS:
+ return _("Results in HIMarks. Higher is better.");
+ }
+
+ return NULL;
+}
diff --git a/modules/benchmark/blowfish.c b/modules/benchmark/blowfish.c
new file mode 100644
index 00000000..f8d2e14a
--- /dev/null
+++ b/modules/benchmark/blowfish.c
@@ -0,0 +1,493 @@
+/*
+blowfish.c: C implementation of the Blowfish algorithm.
+
+Copyright (C) 1997 by Paul Kocher
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+This library 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
+Lesser General Public License for more details.
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+
+
+
+COMMENTS ON USING THIS CODE:
+
+Normal usage is as follows:
+ [1] Allocate a BLOWFISH_CTX. (It may be too big for the stack.)
+ [2] Call Blowfish_Init with a pointer to your BLOWFISH_CTX, a pointer to
+ the key, and the number of bytes in the key.
+ [3] To encrypt a 64-bit block, call Blowfish_Encrypt with a pointer to
+ BLOWFISH_CTX, a pointer to the 32-bit left half of the plaintext
+ and a pointer to the 32-bit right half. The plaintext will be
+ overwritten with the ciphertext.
+ [4] Decryption is the same as encryption except that the plaintext and
+ ciphertext are reversed.
+
+Warning #1: The code does not check key lengths. (Caveat encryptor.)
+Warning #2: Beware that Blowfish keys repeat such that "ab" = "abab".
+Warning #3: It is normally a good idea to zeroize the BLOWFISH_CTX before
+ freeing it.
+Warning #4: Endianness conversions are the responsibility of the caller.
+ (To encrypt bytes on a little-endian platforms, you'll probably want
+ to swap bytes around instead of just casting.)
+Warning #5: Make sure to use a reasonable mode of operation for your
+ application. (If you don't know what CBC mode is, see Warning #7.)
+Warning #6: This code is susceptible to timing attacks.
+Warning #7: Security engineering is risky and non-intuitive. Have someone
+ check your work. If you don't know what you are doing, get help.
+
+
+This is code is fast enough for most applications, but is not optimized for
+speed.
+
+If you require this code under a license other than LGPL, please ask. (I
+can be located using your favorite search engine.) Unfortunately, I do not
+have time to provide unpaid support for everyone who uses this code.
+
+ -- Paul Kocher
+*/
+
+#include "hardinfo.h"
+#include "benchmark.h"
+#include "blowfish.h"
+
+#define N 16
+static const unsigned long ORIG_P[16 + 2] =
+ { 0x243F6A88L, 0x85A308D3L, 0x13198A2EL, 0x03707344L, 0xA4093822L,
+ 0x299F31D0L, 0x082EFA98L, 0xEC4E6C89L, 0x452821E6L, 0x38D01377L,
+ 0xBE5466CFL, 0x34E90C6CL, 0xC0AC29B7L,
+ 0xC97C50DDL, 0x3F84D5B5L, 0xB5470917L, 0x9216D5D9L, 0x8979FB1BL
+};
+
+static const unsigned long ORIG_S[4][256] = {
+ {0xD1310BA6L, 0x98DFB5ACL, 0x2FFD72DBL, 0xD01ADFB7L, 0xB8E1AFEDL,
+ 0x6A267E96L, 0xBA7C9045L, 0xF12C7F99L, 0x24A19947L, 0xB3916CF7L,
+ 0x0801F2E2L, 0x858EFC16L, 0x636920D8L, 0x71574E69L, 0xA458FEA3L,
+ 0xF4933D7EL, 0x0D95748FL, 0x728EB658L, 0x718BCD58L, 0x82154AEEL,
+ 0x7B54A41DL, 0xC25A59B5L, 0x9C30D539L, 0x2AF26013L, 0xC5D1B023L,
+ 0x286085F0L, 0xCA417918L, 0xB8DB38EFL, 0x8E79DCB0L, 0x603A180EL,
+ 0x6C9E0E8BL, 0xB01E8A3EL, 0xD71577C1L, 0xBD314B27L, 0x78AF2FDAL,
+ 0x55605C60L, 0xE65525F3L, 0xAA55AB94L, 0x57489862L, 0x63E81440L,
+ 0x55CA396AL, 0x2AAB10B6L, 0xB4CC5C34L, 0x1141E8CEL, 0xA15486AFL,
+ 0x7C72E993L, 0xB3EE1411L, 0x636FBC2AL, 0x2BA9C55DL, 0x741831F6L,
+ 0xCE5C3E16L, 0x9B87931EL, 0xAFD6BA33L, 0x6C24CF5CL, 0x7A325381L,
+ 0x28958677L, 0x3B8F4898L, 0x6B4BB9AFL, 0xC4BFE81BL, 0x66282193L,
+ 0x61D809CCL, 0xFB21A991L, 0x487CAC60L, 0x5DEC8032L, 0xEF845D5DL,
+ 0xE98575B1L, 0xDC262302L, 0xEB651B88L, 0x23893E81L, 0xD396ACC5L,
+ 0x0F6D6FF3L, 0x83F44239L, 0x2E0B4482L, 0xA4842004L, 0x69C8F04AL,
+ 0x9E1F9B5EL, 0x21C66842L, 0xF6E96C9AL, 0x670C9C61L, 0xABD388F0L,
+ 0x6A51A0D2L, 0xD8542F68L, 0x960FA728L, 0xAB5133A3L, 0x6EEF0B6CL,
+ 0x137A3BE4L, 0xBA3BF050L, 0x7EFB2A98L, 0xA1F1651DL, 0x39AF0176L,
+ 0x66CA593EL, 0x82430E88L, 0x8CEE8619L, 0x456F9FB4L, 0x7D84A5C3L,
+ 0x3B8B5EBEL, 0xE06F75D8L, 0x85C12073L, 0x401A449FL, 0x56C16AA6L,
+ 0x4ED3AA62L, 0x363F7706L, 0x1BFEDF72L, 0x429B023DL, 0x37D0D724L,
+ 0xD00A1248L, 0xDB0FEAD3L, 0x49F1C09BL, 0x075372C9L, 0x80991B7BL,
+ 0x25D479D8L, 0xF6E8DEF7L, 0xE3FE501AL, 0xB6794C3BL, 0x976CE0BDL,
+ 0x04C006BAL, 0xC1A94FB6L, 0x409F60C4L, 0x5E5C9EC2L, 0x196A2463L,
+ 0x68FB6FAFL, 0x3E6C53B5L, 0x1339B2EBL, 0x3B52EC6FL, 0x6DFC511FL,
+ 0x9B30952CL, 0xCC814544L, 0xAF5EBD09L, 0xBEE3D004L, 0xDE334AFDL,
+ 0x660F2807L, 0x192E4BB3L, 0xC0CBA857L, 0x45C8740FL, 0xD20B5F39L,
+ 0xB9D3FBDBL, 0x5579C0BDL, 0x1A60320AL, 0xD6A100C6L, 0x402C7279L,
+ 0x679F25FEL, 0xFB1FA3CCL, 0x8EA5E9F8L, 0xDB3222F8L, 0x3C7516DFL,
+ 0xFD616B15L, 0x2F501EC8L, 0xAD0552ABL, 0x323DB5FAL, 0xFD238760L,
+ 0x53317B48L, 0x3E00DF82L, 0x9E5C57BBL, 0xCA6F8CA0L, 0x1A87562EL,
+ 0xDF1769DBL, 0xD542A8F6L, 0x287EFFC3L, 0xAC6732C6L, 0x8C4F5573L,
+ 0x695B27B0L, 0xBBCA58C8L, 0xE1FFA35DL, 0xB8F011A0L, 0x10FA3D98L,
+ 0xFD2183B8L, 0x4AFCB56CL, 0x2DD1D35BL, 0x9A53E479L, 0xB6F84565L,
+ 0xD28E49BCL, 0x4BFB9790L, 0xE1DDF2DAL, 0xA4CB7E33L, 0x62FB1341L,
+ 0xCEE4C6E8L, 0xEF20CADAL, 0x36774C01L, 0xD07E9EFEL, 0x2BF11FB4L,
+ 0x95DBDA4DL, 0xAE909198L, 0xEAAD8E71L, 0x6B93D5A0L, 0xD08ED1D0L,
+ 0xAFC725E0L, 0x8E3C5B2FL, 0x8E7594B7L, 0x8FF6E2FBL, 0xF2122B64L,
+ 0x8888B812L, 0x900DF01CL, 0x4FAD5EA0L, 0x688FC31CL, 0xD1CFF191L,
+ 0xB3A8C1ADL, 0x2F2F2218L, 0xBE0E1777L, 0xEA752DFEL, 0x8B021FA1L,
+ 0xE5A0CC0FL, 0xB56F74E8L, 0x18ACF3D6L, 0xCE89E299L, 0xB4A84FE0L,
+ 0xFD13E0B7L, 0x7CC43B81L, 0xD2ADA8D9L, 0x165FA266L, 0x80957705L,
+ 0x93CC7314L, 0x211A1477L, 0xE6AD2065L, 0x77B5FA86L, 0xC75442F5L,
+ 0xFB9D35CFL, 0xEBCDAF0CL, 0x7B3E89A0L, 0xD6411BD3L, 0xAE1E7E49L,
+ 0x00250E2DL, 0x2071B35EL, 0x226800BBL, 0x57B8E0AFL, 0x2464369BL,
+ 0xF009B91EL, 0x5563911DL, 0x59DFA6AAL, 0x78C14389L, 0xD95A537FL,
+ 0x207D5BA2L, 0x02E5B9C5L, 0x83260376L, 0x6295CFA9L, 0x11C81968L,
+ 0x4E734A41L, 0xB3472DCAL, 0x7B14A94AL, 0x1B510052L, 0x9A532915L,
+ 0xD60F573FL, 0xBC9BC6E4L, 0x2B60A476L, 0x81E67400L, 0x08BA6FB5L,
+ 0x571BE91FL, 0xF296EC6BL, 0x2A0DD915L, 0xB6636521L, 0xE7B9F9B6L,
+ 0xFF34052EL, 0xC5855664L, 0x53B02D5DL, 0xA99F8FA1L, 0x08BA4799L,
+ 0x6E85076AL}, {0x4B7A70E9L, 0xB5B32944L, 0xDB75092EL,
+ 0xC4192623L, 0xAD6EA6B0L, 0x49A7DF7DL,
+ 0x9CEE60B8L, 0x8FEDB266L, 0xECAA8C71L,
+ 0x699A17FFL, 0x5664526CL, 0xC2B19EE1L,
+ 0x193602A5L, 0x75094C29L, 0xA0591340L,
+ 0xE4183A3EL, 0x3F54989AL, 0x5B429D65L,
+ 0x6B8FE4D6L, 0x99F73FD6L, 0xA1D29C07L,
+ 0xEFE830F5L, 0x4D2D38E6L, 0xF0255DC1L,
+ 0x4CDD2086L, 0x8470EB26L, 0x6382E9C6L,
+ 0x021ECC5EL, 0x09686B3FL, 0x3EBAEFC9L,
+ 0x3C971814L, 0x6B6A70A1L, 0x687F3584L,
+ 0x52A0E286L, 0xB79C5305L, 0xAA500737L,
+ 0x3E07841CL, 0x7FDEAE5CL, 0x8E7D44ECL,
+ 0x5716F2B8L, 0xB03ADA37L, 0xF0500C0DL,
+ 0xF01C1F04L, 0x0200B3FFL, 0xAE0CF51AL,
+ 0x3CB574B2L, 0x25837A58L, 0xDC0921BDL,
+ 0xD19113F9L, 0x7CA92FF6L, 0x94324773L,
+ 0x22F54701L, 0x3AE5E581L, 0x37C2DADCL,
+ 0xC8B57634L, 0x9AF3DDA7L, 0xA9446146L,
+ 0x0FD0030EL, 0xECC8C73EL, 0xA4751E41L,
+ 0xE238CD99L, 0x3BEA0E2FL, 0x3280BBA1L,
+ 0x183EB331L, 0x4E548B38L, 0x4F6DB908L,
+ 0x6F420D03L, 0xF60A04BFL, 0x2CB81290L,
+ 0x24977C79L, 0x5679B072L, 0xBCAF89AFL,
+ 0xDE9A771FL, 0xD9930810L, 0xB38BAE12L,
+ 0xDCCF3F2EL, 0x5512721FL, 0x2E6B7124L,
+ 0x501ADDE6L, 0x9F84CD87L, 0x7A584718L,
+ 0x7408DA17L, 0xBC9F9ABCL, 0xE94B7D8CL,
+ 0xEC7AEC3AL, 0xDB851DFAL, 0x63094366L,
+ 0xC464C3D2L, 0xEF1C1847L, 0x3215D908L,
+ 0xDD433B37L, 0x24C2BA16L, 0x12A14D43L,
+ 0x2A65C451L, 0x50940002L, 0x133AE4DDL,
+ 0x71DFF89EL, 0x10314E55L, 0x81AC77D6L,
+ 0x5F11199BL, 0x043556F1L, 0xD7A3C76BL,
+ 0x3C11183BL, 0x5924A509L, 0xF28FE6EDL,
+ 0x97F1FBFAL, 0x9EBABF2CL, 0x1E153C6EL,
+ 0x86E34570L, 0xEAE96FB1L, 0x860E5E0AL,
+ 0x5A3E2AB3L, 0x771FE71CL, 0x4E3D06FAL,
+ 0x2965DCB9L, 0x99E71D0FL, 0x803E89D6L,
+ 0x5266C825L, 0x2E4CC978L, 0x9C10B36AL,
+ 0xC6150EBAL, 0x94E2EA78L, 0xA5FC3C53L,
+ 0x1E0A2DF4L, 0xF2F74EA7L, 0x361D2B3DL,
+ 0x1939260FL, 0x19C27960L, 0x5223A708L,
+ 0xF71312B6L, 0xEBADFE6EL, 0xEAC31F66L,
+ 0xE3BC4595L, 0xA67BC883L, 0xB17F37D1L,
+ 0x018CFF28L, 0xC332DDEFL, 0xBE6C5AA5L,
+ 0x65582185L, 0x68AB9802L, 0xEECEA50FL,
+ 0xDB2F953BL, 0x2AEF7DADL, 0x5B6E2F84L,
+ 0x1521B628L, 0x29076170L, 0xECDD4775L,
+ 0x619F1510L, 0x13CCA830L, 0xEB61BD96L,
+ 0x0334FE1EL, 0xAA0363CFL, 0xB5735C90L,
+ 0x4C70A239L, 0xD59E9E0BL, 0xCBAADE14L,
+ 0xEECC86BCL, 0x60622CA7L, 0x9CAB5CABL,
+ 0xB2F3846EL, 0x648B1EAFL, 0x19BDF0CAL,
+ 0xA02369B9L, 0x655ABB50L, 0x40685A32L,
+ 0x3C2AB4B3L, 0x319EE9D5L, 0xC021B8F7L,
+ 0x9B540B19L, 0x875FA099L, 0x95F7997EL,
+ 0x623D7DA8L, 0xF837889AL, 0x97E32D77L,
+ 0x11ED935FL, 0x16681281L, 0x0E358829L,
+ 0xC7E61FD6L, 0x96DEDFA1L, 0x7858BA99L,
+ 0x57F584A5L, 0x1B227263L, 0x9B83C3FFL,
+ 0x1AC24696L, 0xCDB30AEBL, 0x532E3054L,
+ 0x8FD948E4L, 0x6DBC3128L, 0x58EBF2EFL,
+ 0x34C6FFEAL, 0xFE28ED61L, 0xEE7C3C73L,
+ 0x5D4A14D9L, 0xE864B7E3L, 0x42105D14L,
+ 0x203E13E0L, 0x45EEE2B6L, 0xA3AAABEAL,
+ 0xDB6C4F15L, 0xFACB4FD0L, 0xC742F442L,
+ 0xEF6ABBB5L, 0x654F3B1DL, 0x41CD2105L,
+ 0xD81E799EL, 0x86854DC7L, 0xE44B476AL,
+ 0x3D816250L, 0xCF62A1F2L, 0x5B8D2646L,
+ 0xFC8883A0L, 0xC1C7B6A3L, 0x7F1524C3L,
+ 0x69CB7492L, 0x47848A0BL, 0x5692B285L,
+ 0x095BBF00L, 0xAD19489DL, 0x1462B174L,
+ 0x23820E00L, 0x58428D2AL, 0x0C55F5EAL,
+ 0x1DADF43EL, 0x233F7061L, 0x3372F092L,
+ 0x8D937E41L, 0xD65FECF1L, 0x6C223BDBL,
+ 0x7CDE3759L, 0xCBEE7460L, 0x4085F2A7L,
+ 0xCE77326EL, 0xA6078084L, 0x19F8509EL,
+ 0xE8EFD855L, 0x61D99735L, 0xA969A7AAL,
+ 0xC50C06C2L, 0x5A04ABFCL, 0x800BCADCL,
+ 0x9E447A2EL, 0xC3453484L, 0xFDD56705L,
+ 0x0E1E9EC9L, 0xDB73DBD3L, 0x105588CDL,
+ 0x675FDA79L, 0xE3674340L, 0xC5C43465L,
+ 0x713E38D8L, 0x3D28F89EL, 0xF16DFF20L,
+ 0x153E21E7L, 0x8FB03D4AL, 0xE6E39F2BL,
+ 0xDB83ADF7L}, {0xE93D5A68L, 0x948140F7L,
+ 0xF64C261CL, 0x94692934L,
+ 0x411520F7L, 0x7602D4F7L,
+ 0xBCF46B2EL, 0xD4A20068L,
+ 0xD4082471L, 0x3320F46AL,
+ 0x43B7D4B7L, 0x500061AFL,
+ 0x1E39F62EL, 0x97244546L,
+ 0x14214F74L, 0xBF8B8840L,
+ 0x4D95FC1DL, 0x96B591AFL,
+ 0x70F4DDD3L, 0x66A02F45L,
+ 0xBFBC09ECL, 0x03BD9785L,
+ 0x7FAC6DD0L, 0x31CB8504L,
+ 0x96EB27B3L, 0x55FD3941L,
+ 0xDA2547E6L, 0xABCA0A9AL,
+ 0x28507825L, 0x530429F4L,
+ 0x0A2C86DAL, 0xE9B66DFBL,
+ 0x68DC1462L, 0xD7486900L,
+ 0x680EC0A4L, 0x27A18DEEL,
+ 0x4F3FFEA2L, 0xE887AD8CL,
+ 0xB58CE006L, 0x7AF4D6B6L,
+ 0xAACE1E7CL, 0xD3375FECL,
+ 0xCE78A399L, 0x406B2A42L,
+ 0x20FE9E35L, 0xD9F385B9L,
+ 0xEE39D7ABL, 0x3B124E8BL,
+ 0x1DC9FAF7L, 0x4B6D1856L,
+ 0x26A36631L, 0xEAE397B2L,
+ 0x3A6EFA74L, 0xDD5B4332L,
+ 0x6841E7F7L, 0xCA7820FBL,
+ 0xFB0AF54EL, 0xD8FEB397L,
+ 0x454056ACL, 0xBA489527L,
+ 0x55533A3AL, 0x20838D87L,
+ 0xFE6BA9B7L, 0xD096954BL,
+ 0x55A867BCL, 0xA1159A58L,
+ 0xCCA92963L, 0x99E1DB33L,
+ 0xA62A4A56L, 0x3F3125F9L,
+ 0x5EF47E1CL, 0x9029317CL,
+ 0xFDF8E802L, 0x04272F70L,
+ 0x80BB155CL, 0x05282CE3L,
+ 0x95C11548L, 0xE4C66D22L,
+ 0x48C1133FL, 0xC70F86DCL,
+ 0x07F9C9EEL, 0x41041F0FL,
+ 0x404779A4L, 0x5D886E17L,
+ 0x325F51EBL, 0xD59BC0D1L,
+ 0xF2BCC18FL, 0x41113564L,
+ 0x257B7834L, 0x602A9C60L,
+ 0xDFF8E8A3L, 0x1F636C1BL,
+ 0x0E12B4C2L, 0x02E1329EL,
+ 0xAF664FD1L, 0xCAD18115L,
+ 0x6B2395E0L, 0x333E92E1L,
+ 0x3B240B62L, 0xEEBEB922L,
+ 0x85B2A20EL, 0xE6BA0D99L,
+ 0xDE720C8CL, 0x2DA2F728L,
+ 0xD0127845L, 0x95B794FDL,
+ 0x647D0862L, 0xE7CCF5F0L,
+ 0x5449A36FL, 0x877D48FAL,
+ 0xC39DFD27L, 0xF33E8D1EL,
+ 0x0A476341L, 0x992EFF74L,
+ 0x3A6F6EABL, 0xF4F8FD37L,
+ 0xA812DC60L, 0xA1EBDDF8L,
+ 0x991BE14CL, 0xDB6E6B0DL,
+ 0xC67B5510L, 0x6D672C37L,
+ 0x2765D43BL, 0xDCD0E804L,
+ 0xF1290DC7L, 0xCC00FFA3L,
+ 0xB5390F92L, 0x690FED0BL,
+ 0x667B9FFBL, 0xCEDB7D9CL,
+ 0xA091CF0BL, 0xD9155EA3L,
+ 0xBB132F88L, 0x515BAD24L,
+ 0x7B9479BFL, 0x763BD6EBL,
+ 0x37392EB3L, 0xCC115979L,
+ 0x8026E297L, 0xF42E312DL,
+ 0x6842ADA7L, 0xC66A2B3BL,
+ 0x12754CCCL, 0x782EF11CL,
+ 0x6A124237L, 0xB79251E7L,
+ 0x06A1BBE6L, 0x4BFB6350L,
+ 0x1A6B1018L, 0x11CAEDFAL,
+ 0x3D25BDD8L, 0xE2E1C3C9L,
+ 0x44421659L, 0x0A121386L,
+ 0xD90CEC6EL, 0xD5ABEA2AL,
+ 0x64AF674EL, 0xDA86A85FL,
+ 0xBEBFE988L, 0x64E4C3FEL,
+ 0x9DBC8057L, 0xF0F7C086L,
+ 0x60787BF8L, 0x6003604DL,
+ 0xD1FD8346L, 0xF6381FB0L,
+ 0x7745AE04L, 0xD736FCCCL,
+ 0x83426B33L, 0xF01EAB71L,
+ 0xB0804187L, 0x3C005E5FL,
+ 0x77A057BEL, 0xBDE8AE24L,
+ 0x55464299L, 0xBF582E61L,
+ 0x4E58F48FL, 0xF2DDFDA2L,
+ 0xF474EF38L, 0x8789BDC2L,
+ 0x5366F9C3L, 0xC8B38E74L,
+ 0xB475F255L, 0x46FCD9B9L,
+ 0x7AEB2661L, 0x8B1DDF84L,
+ 0x846A0E79L, 0x915F95E2L,
+ 0x466E598EL, 0x20B45770L,
+ 0x8CD55591L, 0xC902DE4CL,
+ 0xB90BACE1L, 0xBB8205D0L,
+ 0x11A86248L, 0x7574A99EL,
+ 0xB77F19B6L, 0xE0A9DC09L,
+ 0x662D09A1L, 0xC4324633L,
+ 0xE85A1F02L, 0x09F0BE8CL,
+ 0x4A99A025L, 0x1D6EFE10L,
+ 0x1AB93D1DL, 0x0BA5A4DFL,
+ 0xA186F20FL, 0x2868F169L,
+ 0xDCB7DA83L, 0x573906FEL,
+ 0xA1E2CE9BL, 0x4FCD7F52L,
+ 0x50115E01L, 0xA70683FAL,
+ 0xA002B5C4L, 0x0DE6D027L,
+ 0x9AF88C27L, 0x773F8641L,
+ 0xC3604C06L, 0x61A806B5L,
+ 0xF0177A28L, 0xC0F586E0L,
+ 0x006058AAL, 0x30DC7D62L,
+ 0x11E69ED7L, 0x2338EA63L,
+ 0x53C2DD94L, 0xC2C21634L,
+ 0xBBCBEE56L, 0x90BCB6DEL,
+ 0xEBFC7DA1L, 0xCE591D76L,
+ 0x6F05E409L, 0x4B7C0188L,
+ 0x39720A3DL, 0x7C927C24L,
+ 0x86E3725FL, 0x724D9DB9L,
+ 0x1AC15BB4L, 0xD39EB8FCL,
+ 0xED545578L, 0x08FCA5B5L,
+ 0xD83D7CD3L, 0x4DAD0FC4L,
+ 0x1E50EF5EL, 0xB161E6F8L,
+ 0xA28514D9L, 0x6C51133CL,
+ 0x6FD5C7E7L, 0x56E14EC4L,
+ 0x362ABFCEL, 0xDDC6C837L,
+ 0xD79A3234L, 0x92638212L,
+ 0x670EFA8EL, 0x406000E0L},
+{0x3A39CE37L, 0xD3FAF5CFL, 0xABC27737L, 0x5AC52D1BL, 0x5CB0679EL,
+ 0x4FA33742L, 0xD3822740L, 0x99BC9BBEL, 0xD5118E9DL, 0xBF0F7315L,
+ 0xD62D1C7EL, 0xC700C47BL, 0xB78C1B6BL, 0x21A19045L, 0xB26EB1BEL,
+ 0x6A366EB4L, 0x5748AB2FL, 0xBC946E79L, 0xC6A376D2L, 0x6549C2C8L,
+ 0x530FF8EEL, 0x468DDE7DL, 0xD5730A1DL, 0x4CD04DC6L, 0x2939BBDBL,
+ 0xA9BA4650L, 0xAC9526E8L, 0xBE5EE304L, 0xA1FAD5F0L, 0x6A2D519AL,
+ 0x63EF8CE2L, 0x9A86EE22L, 0xC089C2B8L, 0x43242EF6L, 0xA51E03AAL,
+ 0x9CF2D0A4L, 0x83C061BAL, 0x9BE96A4DL, 0x8FE51550L, 0xBA645BD6L,
+ 0x2826A2F9L, 0xA73A3AE1L, 0x4BA99586L, 0xEF5562E9L, 0xC72FEFD3L,
+ 0xF752F7DAL, 0x3F046F69L, 0x77FA0A59L, 0x80E4A915L, 0x87B08601L,
+ 0x9B09E6ADL, 0x3B3EE593L, 0xE990FD5AL, 0x9E34D797L, 0x2CF0B7D9L,
+ 0x022B8B51L, 0x96D5AC3AL, 0x017DA67DL, 0xD1CF3ED6L, 0x7C7D2D28L,
+ 0x1F9F25CFL, 0xADF2B89BL, 0x5AD6B472L, 0x5A88F54CL, 0xE029AC71L,
+ 0xE019A5E6L, 0x47B0ACFDL, 0xED93FA9BL, 0xE8D3C48DL, 0x283B57CCL,
+ 0xF8D56629L, 0x79132E28L, 0x785F0191L, 0xED756055L, 0xF7960E44L,
+ 0xE3D35E8CL, 0x15056DD4L, 0x88F46DBAL, 0x03A16125L, 0x0564F0BDL,
+ 0xC3EB9E15L, 0x3C9057A2L, 0x97271AECL, 0xA93A072AL, 0x1B3F6D9BL,
+ 0x1E6321F5L, 0xF59C66FBL, 0x26DCF319L, 0x7533D928L, 0xB155FDF5L,
+ 0x03563482L, 0x8ABA3CBBL, 0x28517711L, 0xC20AD9F8L, 0xABCC5167L,
+ 0xCCAD925FL, 0x4DE81751L, 0x3830DC8EL, 0x379D5862L, 0x9320F991L,
+ 0xEA7A90C2L, 0xFB3E7BCEL, 0x5121CE64L, 0x774FBE32L, 0xA8B6E37EL,
+ 0xC3293D46L, 0x48DE5369L, 0x6413E680L, 0xA2AE0810L, 0xDD6DB224L,
+ 0x69852DFDL, 0x09072166L, 0xB39A460AL, 0x6445C0DDL, 0x586CDECFL,
+ 0x1C20C8AEL, 0x5BBEF7DDL, 0x1B588D40L, 0xCCD2017FL, 0x6BB4E3BBL,
+ 0xDDA26A7EL, 0x3A59FF45L, 0x3E350A44L, 0xBCB4CDD5L, 0x72EACEA8L,
+ 0xFA6484BBL, 0x8D6612AEL, 0xBF3C6F47L, 0xD29BE463L, 0x542F5D9EL,
+ 0xAEC2771BL, 0xF64E6370L, 0x740E0D8DL, 0xE75B1357L, 0xF8721671L,
+ 0xAF537D5DL, 0x4040CB08L, 0x4EB4E2CCL, 0x34D2466AL, 0x0115AF84L,
+ 0xE1B00428L, 0x95983A1DL, 0x06B89FB4L, 0xCE6EA048L, 0x6F3F3B82L,
+ 0x3520AB82L, 0x011A1D4BL, 0x277227F8L, 0x611560B1L, 0xE7933FDCL,
+ 0xBB3A792BL, 0x344525BDL, 0xA08839E1L, 0x51CE794BL, 0x2F32C9B7L,
+ 0xA01FBAC9L, 0xE01CC87EL, 0xBCC7D1F6L, 0xCF0111C3L, 0xA1E8AAC7L,
+ 0x1A908749L, 0xD44FBD9AL, 0xD0DADECBL, 0xD50ADA38L, 0x0339C32AL,
+ 0xC6913667L, 0x8DF9317CL, 0xE0B12B4FL, 0xF79E59B7L, 0x43F5BB3AL,
+ 0xF2D519FFL, 0x27D9459CL, 0xBF97222CL, 0x15E6FC2AL, 0x0F91FC71L,
+ 0x9B941525L, 0xFAE59361L, 0xCEB69CEBL, 0xC2A86459L, 0x12BAA8D1L,
+ 0xB6C1075EL, 0xE3056A0CL, 0x10D25065L, 0xCB03A442L, 0xE0EC6E0EL,
+ 0x1698DB3BL, 0x4C98A0BEL, 0x3278E964L, 0x9F1F9532L, 0xE0D392DFL,
+ 0xD3A0342BL, 0x8971F21EL, 0x1B0A7441L, 0x4BA3348CL, 0xC5BE7120L,
+ 0xC37632D8L, 0xDF359F8DL, 0x9B992F2EL, 0xE60B6F47L, 0x0FE3F11DL,
+ 0xE54CDA54L, 0x1EDAD891L, 0xCE6279CFL, 0xCD3E7E6FL, 0x1618B166L,
+ 0xFD2C1D05L, 0x848FD2C5L, 0xF6FB2299L, 0xF523F357L, 0xA6327623L,
+ 0x93A83531L, 0x56CCCD02L, 0xACF08162L, 0x5A75EBB5L, 0x6E163697L,
+ 0x88D273CCL, 0xDE966292L, 0x81B949D0L, 0x4C50901BL, 0x71C65614L,
+ 0xE6C6C7BDL, 0x327A140AL, 0x45E1D006L, 0xC3F27B9AL, 0xC9AA53FDL,
+ 0x62A80F00L, 0xBB25BFE2L, 0x35BDD2F6L, 0x71126905L, 0xB2040222L,
+ 0xB6CBCF7CL, 0xCD769C2BL, 0x53113EC0L, 0x1640E3D3L, 0x38ABBD60L,
+ 0x2547ADF0L, 0xBA38209CL, 0xF746CE76L, 0x77AFA1C5L, 0x20756060L,
+ 0x85CBFE4EL, 0x8AE88DD8L, 0x7AAAF9B0L, 0x4CF9AA7EL, 0x1948C25CL,
+ 0x02FB8A8CL, 0x01C36AE4L, 0xD6EBE1F9L, 0x90D4F869L, 0xA65CDEA0L,
+ 0x3F09252DL, 0xC208E69FL, 0xB74E6132L, 0xCE77E25BL, 0x578FDFE3L,
+ 0x3AC372E6L}
+};
+
+static unsigned long F(BLOWFISH_CTX * ctx, unsigned long x)
+{
+ unsigned short a, b, c, d;
+ unsigned long y;
+ d = (unsigned short) (x & 0xFF);
+ x >>= 8;
+ c = (unsigned short) (x & 0xFF);
+ x >>= 8;
+ b = (unsigned short) (x & 0xFF);
+ x >>= 8;
+ a = (unsigned short) (x & 0xFF);
+ y = ctx->S[0][a] + ctx->S[1][b];
+ y = y ^ ctx->S[2][c];
+ y = y + ctx->S[3][d];
+ return y;
+}
+
+void Blowfish_Encrypt(BLOWFISH_CTX * ctx, unsigned long *xl,
+ unsigned long *xr)
+{
+ unsigned long Xl;
+ unsigned long Xr;
+ unsigned long temp;
+ short i;
+ Xl = *xl;
+ Xr = *xr;
+ for (i = 0; i < N; ++i) {
+ Xl = Xl ^ ctx->P[i];
+ Xr = F(ctx, Xl) ^ Xr;
+ temp = Xl;
+ Xl = Xr;
+ Xr = temp;
+ }
+ temp = Xl;
+ Xl = Xr;
+ Xr = temp;
+ Xr = Xr ^ ctx->P[N];
+ Xl = Xl ^ ctx->P[N + 1];
+ *xl = Xl;
+ *xr = Xr;
+}
+
+void Blowfish_Decrypt(BLOWFISH_CTX * ctx, unsigned long *xl,
+ unsigned long *xr)
+{
+ unsigned long Xl;
+ unsigned long Xr;
+ unsigned long temp;
+ short i;
+ Xl = *xl;
+ Xr = *xr;
+ for (i = N + 1; i > 1; --i) {
+ Xl = Xl ^ ctx->P[i];
+ Xr = F(ctx, Xl) ^ Xr;
+
+ /* Exchange Xl and Xr */
+ temp = Xl;
+ Xl = Xr;
+ Xr = temp;
+ }
+
+ /* Exchange Xl and Xr */
+ temp = Xl;
+ Xl = Xr;
+ Xr = temp;
+ Xr = Xr ^ ctx->P[1];
+ Xl = Xl ^ ctx->P[0];
+ *xl = Xl;
+ *xr = Xr;
+}
+
+void Blowfish_Init(BLOWFISH_CTX * ctx, unsigned char *key, int keyLen)
+{
+ int i, j, k;
+ unsigned long data, datal, datar;
+ for (i = 0; i < 4; i++) {
+ for (j = 0; j < 256; j++)
+ ctx->S[i][j] = ORIG_S[i][j];
+ }
+ j = 0;
+ for (i = 0; i < N + 2; ++i) {
+ data = 0x00000000;
+ for (k = 0; k < 4; ++k) {
+ data = (data << 8) | key[j];
+ j = j + 1;
+ if (j >= keyLen)
+ j = 0;
+ }
+ ctx->P[i] = ORIG_P[i] ^ data;
+ }
+ datal = 0x00000000;
+ datar = 0x00000000;
+ for (i = 0; i < N + 2; i += 2) {
+ Blowfish_Encrypt(ctx, &datal, &datar);
+ ctx->P[i] = datal;
+ ctx->P[i + 1] = datar;
+ }
+ for (i = 0; i < 4; ++i) {
+ for (j = 0; j < 256; j += 2) {
+ Blowfish_Encrypt(ctx, &datal, &datar);
+ ctx->S[i][j] = datal;
+ ctx->S[i][j + 1] = datar;
+ }
+ }
+}
diff --git a/modules/benchmark/blowfish2.c b/modules/benchmark/blowfish2.c
new file mode 100644
index 00000000..7426bef9
--- /dev/null
+++ b/modules/benchmark/blowfish2.c
@@ -0,0 +1,83 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2017 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 or later.
+ *
+ * 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"
+#include "blowfish.h"
+
+/* if anything changes in this block, increment revision */
+#define BENCH_REVISION 1
+#define CRUNCH_TIME 7
+#define BENCH_DATA_SIZE 65536
+#define BENCH_DATA_MD5 "c25cf5c889f7bead2ff39788eedae37b"
+#define BLOW_KEY "Has my shampoo arrived?"
+#define BLOW_KEY_MD5 "6eac709cca51a228bfa70150c9c5a7c4"
+
+static gpointer bfish_exec(const void *in_data, gint thread_number)
+{
+ unsigned char key[] = BLOW_KEY;
+ unsigned char *data = NULL;
+ unsigned long data_len = BENCH_DATA_SIZE, i = 0;
+ BLOWFISH_CTX ctx;
+
+ data = malloc(BENCH_DATA_SIZE);
+ memcpy(data, in_data, BENCH_DATA_SIZE);
+
+ Blowfish_Init(&ctx, key, strlen(key));
+ for(i = 0; i < data_len; i += 8) {
+ Blowfish_Encrypt(&ctx, (unsigned long*)&data[i], (unsigned long*)&data[i+4]);
+ }
+ for(i = 0; i < data_len; i += 8) {
+ Blowfish_Decrypt(&ctx, (unsigned long*)&data[i], (unsigned long*)&data[i+4]);
+ }
+
+ free(data);
+ return NULL;
+}
+
+void benchmark_bfish_do(int threads, int entry, const char *status)
+{
+ bench_value r = EMPTY_BENCH_VALUE;
+ gchar *test_data = get_test_data(BENCH_DATA_SIZE);
+ if (!test_data) return;
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update(status);
+
+ gchar *k = md5_digest_str(BLOW_KEY, strlen(BLOW_KEY));
+ if (!SEQ(k, BLOW_KEY_MD5))
+ bench_msg("test key has different md5sum: expected %s, actual %s", BLOW_KEY_MD5, k);
+ gchar *d = md5_digest_str(test_data, BENCH_DATA_SIZE);
+ if (!SEQ(d, BENCH_DATA_MD5))
+ bench_msg("test data has different md5sum: expected %s, actual %s", BENCH_DATA_MD5, d);
+
+ r = benchmark_crunch_for(CRUNCH_TIME, threads, bfish_exec, test_data);
+ r.result /= 100;
+ r.revision = BENCH_REVISION;
+ snprintf(r.extra, 255, "%0.1fs, k:%s, d:%s", (double)CRUNCH_TIME, k, d);
+
+ g_free(test_data);
+ g_free(k);
+ g_free(d);
+
+ bench_results[entry] = r;
+}
+
+void benchmark_bfish_threads(void) { benchmark_bfish_do(0, BENCHMARK_BLOWFISH_THREADS, "Performing Blowfish benchmark (multi-thread)..."); }
+void benchmark_bfish_single(void) { benchmark_bfish_do(1, BENCHMARK_BLOWFISH_SINGLE, "Performing Blowfish benchmark (single-thread)..."); }
+void benchmark_bfish_cores(void) { benchmark_bfish_do(-1, BENCHMARK_BLOWFISH_CORES, "Performing Blowfish benchmark (multi-core)..."); }
diff --git a/modules/benchmark/cryptohash.c b/modules/benchmark/cryptohash.c
new file mode 100644
index 00000000..6daef545
--- /dev/null
+++ b/modules/benchmark/cryptohash.c
@@ -0,0 +1,89 @@
+/*
+ * HardInfo - System Information and Benchmark
+ * Copyright (C) 2003-2007 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 or later.
+ *
+ * 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 "md5.h"
+#include "sha1.h"
+#include "benchmark.h"
+
+/* if anything changes in this block, increment revision */
+#define BENCH_REVISION 2
+#define BENCH_DATA_SIZE 65536
+#define CRUNCH_TIME 5
+#define BENCH_DATA_MD5 "c25cf5c889f7bead2ff39788eedae37b"
+#define STEPS 250
+
+inline void md5_step(char *data, glong srclen)
+{
+ struct MD5Context ctx;
+ guchar checksum[16];
+
+ MD5Init(&ctx);
+ MD5Update(&ctx, (guchar *)data, srclen);
+ MD5Final(checksum, &ctx);
+}
+
+inline void sha1_step(char *data, glong srclen)
+{
+ SHA1_CTX ctx;
+ guchar checksum[20];
+
+ SHA1Init(&ctx);
+ SHA1Update(&ctx, (guchar*)data, srclen);
+ SHA1Final(checksum, &ctx);
+}
+
+static gpointer cryptohash_for(void *in_data, gint thread_number)
+{
+ unsigned int i;
+
+ for (i = 0;i <= STEPS; i++) {
+ if (i & 1) {
+ md5_step(in_data, BENCH_DATA_SIZE);
+ } else {
+ sha1_step(in_data, BENCH_DATA_SIZE);
+ }
+ }
+
+ return NULL;
+}
+
+void
+benchmark_cryptohash(void)
+{
+ bench_value r = EMPTY_BENCH_VALUE;
+ gchar *test_data = get_test_data(BENCH_DATA_SIZE);
+ if (!test_data) return;
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update("Running CryptoHash benchmark...");
+
+ gchar *d = md5_digest_str(test_data, BENCH_DATA_SIZE);
+ if (!SEQ(d, BENCH_DATA_MD5))
+ bench_msg("test data has different md5sum: expected %s, actual %s", BENCH_DATA_MD5, d);
+
+ r = benchmark_crunch_for(CRUNCH_TIME, 0, cryptohash_for, test_data);
+ r.revision = BENCH_REVISION;
+ snprintf(r.extra, 255, "r:%d, d:%s", STEPS, d);
+
+ g_free(test_data);
+ g_free(d);
+
+ r.result /= 10;
+
+ bench_results[BENCHMARK_CRYPTOHASH] = r;
+}
diff --git a/modules/benchmark/drawing.c b/modules/benchmark/drawing.c
new file mode 100644
index 00000000..e92b9d62
--- /dev/null
+++ b/modules/benchmark/drawing.c
@@ -0,0 +1,33 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2007 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 or later.
+ *
+ * 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 "benchmark.h"
+#include "guibench.h"
+
+void
+benchmark_gui(void)
+{
+ bench_value r = EMPTY_BENCH_VALUE;
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update("Running drawing benchmark...");
+
+ r.result = guibench(); //TODO: explain in code comments
+
+ bench_results[BENCHMARK_GUI] = r;
+}
diff --git a/modules/benchmark/fbench.c b/modules/benchmark/fbench.c
new file mode 100644
index 00000000..cf1ff934
--- /dev/null
+++ b/modules/benchmark/fbench.c
@@ -0,0 +1,747 @@
+/*
+
+ John Walker's Floating Point Benchmark, derived from...
+
+ Marinchip Interactive Lens Design System
+
+ John Walker December 1980
+
+ By John Walker
+ https://www.fourmilab.ch/
+
+ This program may be used, distributed, and modified freely as
+ long as the origin information is preserved.
+
+ This is a complete optical design raytracing algorithm,
+ stripped of its user interface and recast into portable C. It
+ not only determines execution speed on an extremely floating
+ point (including trig function) intensive real-world
+ application, it checks accuracy on an algorithm that is
+ exquisitely sensitive to errors. The performance of this
+ program is typically far more sensitive to changes in the
+ efficiency of the trigonometric library routines than the
+ average floating point program.
+
+ The benchmark may be compiled in two modes. If the symbol
+ INTRIG is defined, built-in trigonometric and square root
+ routines will be used for all calculations. Timings made with
+ INTRIG defined reflect the machine's basic floating point
+ performance for the arithmetic operators. If INTRIG is not
+ defined, the system library <math.h> functions are used.
+ Results with INTRIG not defined reflect the system's library
+ performance and/or floating point hardware support for trig
+ functions and square root. Results with INTRIG defined are a
+ good guide to general floating point performance, while
+ results with INTRIG undefined indicate the performance of an
+ application which is math function intensive.
+
+ Special note regarding errors in accuracy: this program has
+ generated numbers identical to the last digit it formats and
+ checks on the following machines, floating point
+ architectures, and languages:
+
+ Marinchip 9900 QBASIC IBM 370 double-precision (REAL * 8) format
+
+ IBM PC / XT / AT Lattice C IEEE 64 bit, 80 bit temporaries
+ High C same, in line 80x87 code
+ BASICA "Double precision"
+ Quick BASIC IEEE double precision, software routines
+
+ Sun 3 C IEEE 64 bit, 80 bit temporaries,
+ in-line 68881 code, in-line FPA code.
+
+ MicroVAX II C Vax "G" format floating point
+
+ Macintosh Plus MPW C SANE floating point, IEEE 64 bit format
+ implemented in ROM.
+
+ Inaccuracies reported by this program should be taken VERY
+ SERIOUSLY INDEED, as the program has been demonstrated to be
+ invariant under changes in floating point format, as long as
+ the format is a recognised double precision format. If you
+ encounter errors, please remember that they are just as likely
+ to be in the floating point editing library or the
+ trigonometric libraries as in the low level operator code.
+
+ The benchmark assumes that results are basically reliable, and
+ only tests the last result computed against the reference. If
+ you're running on a suspect system you can compile this
+ program with ACCURACY defined. This will generate a version
+ which executes as an infinite loop, performing the ray trace
+ and checking the results on every pass. All incorrect results
+ will be reported.
+
+ Representative timings are given below. All have been
+ normalised as if run for 1000 iterations.
+
+ Time in seconds Computer, Compiler, and notes
+ Normal INTRIG
+
+ 3466.00 4031.00 Commodore 128, 2 Mhz 8510 with software floating
+ point. Abacus Software/Data-Becker Super-C 128,
+ version 3.00, run in fast (2 Mhz) mode. Note:
+ the results generated by this system differed
+ from the reference results in the 8th to 10th
+ decimal place.
+
+ 3290.00 IBM PC/AT 6 Mhz, Microsoft/IBM BASICA version A3.00.
+ Run with the "/d" switch, software floating point.
+
+ 2131.50 IBM PC/AT 6 Mhz, Lattice C version 2.14, small model.
+ This version of Lattice compiles subroutine
+ calls which either do software floating point
+ or use the 80x87. The machine on which I ran
+ this had an 80287, but the results were so bad
+ I wonder if it was being used.
+
+ 1598.00 Macintosh Plus, MPW C, SANE Software floating point.
+
+ 1582.13 Marinchip 9900 2 Mhz, QBASIC compiler with software
+ floating point. This was a QBASIC version of the
+ program which contained the identical algorithm.
+
+ 404.00 IBM PC/AT 6 Mhz, Microsoft QuickBASIC version 2.0.
+ Software floating point.
+
+ 165.15 IBM PC/AT 6 Mhz, Metaware High C version 1.3, small
+ model. This was compiled to call subroutines for
+ floating point, and the machine contained an 80287
+ which was used by the subroutines.
+
+ 143.20 Macintosh II, MPW C, SANE calls. I was unable to
+ determine whether SANE was using the 68881 chip or
+ not.
+
+ 121.80 Sun 3/160 16 Mhz, Sun C. Compiled with -fsoft switch
+ which executes floating point in software.
+
+ 78.78 110.11 IBM RT PC (Model 6150). IBM AIX 1.0 C compiler
+ with -O switch.
+
+ 75.2 254.0 Microsoft Quick C 1.0, in-line 8087 instructions,
+ compiled with 80286 optimisation on. (Switches
+ were -Ol -FPi87-G2 -AS). Small memory model.
+
+ 69.50 IBM PC/AT 6Mhz, Borland Turbo BASIC 1.0. Compiled
+ in "8087 required" mode to generate in-line
+ code for the math coprocessor.
+
+ 66.96 IBM PC/AT 6Mhz, Microsoft QuickBASIC 4.0. This
+ release of QuickBASIC compiles code for the
+ 80287 math coprocessor.
+
+ 66.36 206.35 IBM PC/AT 6Mhz, Metaware High C version 1.3, small
+ model. This was compiled with in-line code for the
+ 80287 math coprocessor. Trig functions still call
+ library routines.
+
+ 63.07 220.43 IBM PC/AT, 6Mhz, Borland Turbo C, in-line 8087 code,
+ small model, word alignment, no stack checking,
+ 8086 code mode.
+
+ 17.18 Apollo DN-3000, 12 Mhz 68020 with 68881, compiled
+ with in-line code for the 68881 coprocessor.
+ According to Apollo, the library routines are chosen
+ at runtime based on coprocessor presence. Since the
+ coprocessor was present, the library is supposed to
+ use in-line floating point code.
+
+ 15.55 27.56 VAXstation II GPX. Compiled and executed under
+ VAX/VMS C.
+
+ 15.14 37.93 Macintosh II, Unix system V. Green Hills 68020
+ Unix compiler with in-line code for the 68881
+ coprocessor (-O -ZI switches).
+
+ 12.69 Sun 3/160 16 Mhz, Sun C. Compiled with -fswitch,
+ which calls a subroutine to select the fastest
+ floating point processor. This was using the 68881.
+
+ 11.74 26.73 Compaq Deskpro 386, 16 Mhz 80386 with 16 Mhz 80387.
+ Metaware High C version 1.3, compiled with in-line
+ for the math coprocessor (but not optimised for the
+ 80386/80387). Trig functions still call library
+ routines.
+
+ 8.43 30.49 Sun 3/160 16 Mhz, Sun C. Compiled with -f68881,
+ generating in-line MC68881 instructions. Trig
+ functions still call library routines.
+
+ 6.29 25.17 Sun 3/260 25 Mhz, Sun C. Compiled with -f68881,
+ generating in-line MC68881 instructions. Trig
+ functions still call library routines.
+
+ 4.57 Sun 3/260 25 Mhz, Sun FORTRAN 77. Compiled with
+ -O -f68881, generating in-line MC68881 instructions.
+ Trig functions are compiled in-line. This used
+ the FORTRAN 77 version of the program, FBFORT77.F.
+
+ 4.00 14.20 Sun386i/25 Mhz model 250, Sun C compiler.
+
+ 4.00 14.00 Sun386i/25 Mhz model 250, Metaware C.
+
+ 3.10 12.00 Compaq 386/387 25 Mhz running SCO Xenix 2.
+ Compiled with Metaware HighC 386, optimized
+ for 386.
+
+ 3.00 12.00 Compaq 386/387 25MHZ optimized for 386/387.
+
+ 2.96 5.17 Sun 4/260, Sparc RISC processor. Sun C,
+ compiled with the -O2 switch for global
+ optimisation.
+
+ 2.47 COMPAQ 486/25, secondary cache disabled, High C,
+ 486/387, inline f.p., small memory model.
+
+ 2.20 3.40 Data General Motorola 88000, 16 Mhz, Gnu C.
+
+ 1.56 COMPAQ 486/25, 128K secondary cache, High C, 486/387,
+ inline f.p., small memory model.
+
+ 0.66 1.50 DEC Pmax, Mips processor.
+
+ 0.63 0.91 Sun SparcStation 2, Sun C (SunOS 4.1.1) with
+ -O4 optimisation and "/usr/lib/libm.il" inline
+ floating point.
+
+ 0.60 1.07 Intel 860 RISC processor, 33 Mhz, Greenhills
+ C compiler.
+
+ 0.40 0.90 Dec 3MAX, MIPS 3000 processor, -O4.
+
+ 0.31 0.90 IBM RS/6000, -O.
+
+ 0.1129 0.2119 Dell Dimension XPS P133c, Pentium 133 MHz,
+ Windows 95, Microsoft Visual C 5.0.
+
+ 0.0883 0.2166 Silicon Graphics Indigo², MIPS R4400,
+ 175 Mhz, "-O3".
+
+ 0.0351 0.0561 Dell Dimension XPS R100, Pentium II 400 MHz,
+ Windows 98, Microsoft Visual C 5.0.
+
+ 0.0312 0.0542 Sun Ultra 2, UltraSPARC V9, 300 MHz, Solaris
+ 2.5.1.
+
+ 0.00862 0.01074 Dell Inspiron 9100, Pentium 4, 3.4 GHz, gcc -O3.
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef INTRIG
+#include <math.h>
+#endif
+
+#define cot(x) (1.0 / tan(x))
+
+#define TRUE 1
+#define FALSE 0
+
+#define max_surfaces 10
+
+/* Local variables */
+
+/*static char tbfr[132];*/
+
+static short current_surfaces;
+static short paraxial;
+
+static double clear_aperture;
+
+static double aberr_lspher;
+static double aberr_osc;
+static double aberr_lchrom;
+
+static double max_lspher;
+static double max_osc;
+static double max_lchrom;
+
+static double radius_of_curvature;
+static double object_distance;
+static double ray_height;
+static double axis_slope_angle;
+static double from_index;
+static double to_index;
+
+static double spectral_line[9];
+static double s[max_surfaces][5];
+static double od_sa[2][2];
+
+ /*static char outarr[8][80];*//* Computed output of program goes here */
+
+static int itercount; /* The iteration counter for the main loop
+ in the program is made global so that
+ the compiler should not be allowed to
+ optimise out the loop over the ray
+ tracing code. */
+
+#define ITERATIONS 300
+static int niter = ITERATIONS; /* Iteration counter */
+
+#if 0
+static char *refarr[] = { /* Reference results. These happen to
+ be derived from a run on Microsoft
+ Quick BASIC on the IBM PC/AT. */
+
+ " Marginal ray 47.09479120920 0.04178472683",
+ " Paraxial ray 47.08372160249 0.04177864821",
+ "Longitudinal spherical aberration: -0.01106960671",
+ " (Maximum permissible): 0.05306749907",
+ "Offense against sine condition (coma): 0.00008954761",
+ " (Maximum permissible): 0.00250000000",
+ "Axial chromatic aberration: 0.00448229032",
+ " (Maximum permissible): 0.05306749907"
+};
+#endif
+
+/* The test case used in this program is the design for a 4 inch
+ achromatic telescope objective used as the example in Wyld's
+ classic work on ray tracing by hand, given in Amateur Telescope
+ Making, Volume 3. */
+
+static double testcase[4][4] = {
+ {27.05, 1.5137, 63.6, 0.52},
+ {-16.68, 1, 0, 0.138},
+ {-16.68, 1.6164, 36.7, 0.38},
+ {-78.1, 1, 0, 0}
+};
+
+/* Internal trig functions (used only if INTRIG is defined). These
+ standard functions may be enabled to obtain timings that reflect
+ the machine's floating point performance rather than the speed of
+ its trig function evaluation. */
+
+#ifdef INTRIG
+
+/* The following definitions should keep you from getting intro trouble
+ with compilers which don't let you redefine intrinsic functions. */
+
+#define sin I_sin
+#define cos I_cos
+#define tan I_tan
+#define sqrt I_sqrt
+#define atan I_atan
+#define atan2 I_atan2
+#define asin I_asin
+
+#define fabs(x) ((x < 0.0) ? -x : x)
+
+#define pic 3.1415926535897932
+
+/* Commonly used constants */
+
+static double pi = pic,
+ twopi = pic * 2.0,
+ piover4 = pic / 4.0, fouroverpi = 4.0 / pic, piover2 = pic / 2.0;
+
+/* Coefficients for ATAN evaluation */
+
+static double atanc[] = {
+ 0.0,
+ 0.4636476090008061165,
+ 0.7853981633974483094,
+ 0.98279372324732906714,
+ 1.1071487177940905022,
+ 1.1902899496825317322,
+ 1.2490457723982544262,
+ 1.2924966677897852673,
+ 1.3258176636680324644
+};
+
+/* aint(x) Return integer part of number. Truncates towards 0 */
+
+double aint(x)
+double x;
+{
+ long l;
+
+ /* Note that this routine cannot handle the full floating point
+ number range. This function should be in the machine-dependent
+ floating point library! */
+
+ l = x;
+ if ((int) (-0.5) != 0 && l < 0)
+ l++;
+ x = l;
+ return x;
+}
+
+/* sin(x) Return sine, x in radians */
+
+static double sin(x)
+double x;
+{
+ int sign;
+ double y, r, z;
+
+ x = (((sign = (x < 0.0)) != 0) ? -x : x);
+
+ if (x > twopi)
+ x -= (aint(x / twopi) * twopi);
+
+ if (x > pi) {
+ x -= pi;
+ sign = !sign;
+ }
+
+ if (x > piover2)
+ x = pi - x;
+
+ if (x < piover4) {
+ y = x * fouroverpi;
+ z = y * y;
+ r = y *
+ (((((((-0.202253129293E-13 * z + 0.69481520350522E-11) * z -
+ 0.17572474176170806E-8) * z +
+ 0.313361688917325348E-6) * z -
+ 0.365762041821464001E-4) * z +
+ 0.249039457019271628E-2) * z - 0.0807455121882807815) * z +
+ 0.785398163397448310);
+ } else {
+ y = (piover2 - x) * fouroverpi;
+ z = y * y;
+ r = ((((((-0.38577620372E-12 * z + 0.11500497024263E-9) * z -
+ 0.2461136382637005E-7) * z +
+ 0.359086044588581953E-5) * z -
+ 0.325991886926687550E-3) * z + 0.0158543442438154109) * z -
+ 0.308425137534042452) * z + 1.0;
+ }
+ return sign ? -r : r;
+}
+
+/* cos(x) Return cosine, x in radians, by identity */
+
+static double cos(x)
+double x;
+{
+ x = (x < 0.0) ? -x : x;
+ if (x > twopi) /* Do range reduction here to limit */
+ x = x - (aint(x / twopi) * twopi); /* roundoff on add of PI/2 */
+ return sin(x + piover2);
+}
+
+/* tan(x) Return tangent, x in radians, by identity */
+
+static double tan(x)
+double x;
+{
+ return sin(x) / cos(x);
+}
+
+/* sqrt(x) Return square root. Initial guess, then Newton-
+ Raphson refinement */
+
+double sqrt(x)
+double x;
+{
+ double c, cl, y;
+ int n;
+
+ if (x == 0.0)
+ return 0.0;
+
+ if (x < 0.0) {
+ fprintf(stderr,
+ "\nGood work! You tried to take the square root of %g",
+ x);
+ fprintf(stderr,
+ "\nunfortunately, that is too complex for me to handle.\n");
+ exit(1);
+ }
+
+ y = (0.154116 + 1.893872 * x) / (1.0 + 1.047988 * x);
+
+ c = (y - x / y) / 2.0;
+ cl = 0.0;
+ for (n = 50; c != cl && n--;) {
+ y = y - c;
+ cl = c;
+ c = (y - x / y) / 2.0;
+ }
+ return y;
+}
+
+/* atan(x) Return arctangent in radians,
+ range -pi/2 to pi/2 */
+
+static double atan(x)
+double x;
+{
+ int sign, l, y;
+ double a, b, z;
+
+ x = (((sign = (x < 0.0)) != 0) ? -x : x);
+ l = 0;
+
+ if (x >= 4.0) {
+ l = -1;
+ x = 1.0 / x;
+ y = 0;
+ goto atl;
+ } else {
+ if (x < 0.25) {
+ y = 0;
+ goto atl;
+ }
+ }
+
+ y = aint(x / 0.5);
+ z = y * 0.5;
+ x = (x - z) / (x * z + 1);
+
+ atl:
+ z = x * x;
+ b = ((((893025.0 * z + 49116375.0) * z + 425675250.0) * z +
+ 1277025750.0) * z + 1550674125.0) * z + 654729075.0;
+ a = (((13852575.0 * z + 216602100.0) * z + 891080190.0) * z +
+ 1332431100.0) * z + 654729075.0;
+ a = (a / b) * x + atanc[y];
+ if (l)
+ a = piover2 - a;
+ return sign ? -a : a;
+}
+
+/* atan2(y,x) Return arctangent in radians of y/x,
+ range -pi to pi */
+
+static double atan2(y, x)
+double y, x;
+{
+ double temp;
+
+ if (x == 0.0) {
+ if (y == 0.0) /* Special case: atan2(0,0) = 0 */
+ return 0.0;
+ else if (y > 0)
+ return piover2;
+ else
+ return -piover2;
+ }
+ temp = atan(y / x);
+ if (x < 0.0) {
+ if (y >= 0.0)
+ temp += pic;
+ else
+ temp -= pic;
+ }
+ return temp;
+}
+
+/* asin(x) Return arcsine in radians of x */
+
+static double asin(x)
+double x;
+{
+ if (fabs(x) > 1.0) {
+ fprintf(stderr,
+ "\nInverse trig functions lose much of their gloss when");
+ fprintf(stderr,
+ "\ntheir arguments are greater than 1, such as the");
+ fprintf(stderr, "\nvalue %g you passed.\n", x);
+ exit(1);
+ }
+ return atan2(x, sqrt(1 - x * x));
+}
+#endif
+
+/* Calculate passage through surface
+
+ If the variable PARAXIAL is true, the trace through the
+ surface will be done using the paraxial approximations.
+ Otherwise, the normal trigonometric trace will be done.
+
+ This routine takes the following inputs:
+
+ RADIUS_OF_CURVATURE Radius of curvature of surface
+ being crossed. If 0, surface is
+ plane.
+
+ OBJECT_DISTANCE Distance of object focus from
+ lens vertex. If 0, incoming
+ rays are parallel and
+ the following must be specified:
+
+ RAY_HEIGHT Height of ray from axis. Only
+ relevant if OBJECT.DISTANCE == 0
+
+ AXIS_SLOPE_ANGLE Angle incoming ray makes with axis
+ at intercept
+
+ FROM_INDEX Refractive index of medium being left
+
+ TO_INDEX Refractive index of medium being
+ entered.
+
+ The outputs are the following variables:
+
+ OBJECT_DISTANCE Distance from vertex to object focus
+ after refraction.
+
+ AXIS_SLOPE_ANGLE Angle incoming ray makes with axis
+ at intercept after refraction.
+
+*/
+
+static void transit_surface()
+{
+ double iang, /* Incidence angle */
+ rang, /* Refraction angle */
+ iang_sin, /* Incidence angle sin */
+ rang_sin, /* Refraction angle sin */
+ old_axis_slope_angle, sagitta;
+
+ if (paraxial) {
+ if (radius_of_curvature != 0.0) {
+ if (object_distance == 0.0) {
+ axis_slope_angle = 0.0;
+ iang_sin = ray_height / radius_of_curvature;
+ } else
+ iang_sin = ((object_distance -
+ radius_of_curvature) / radius_of_curvature) *
+ axis_slope_angle;
+
+ rang_sin = (from_index / to_index) * iang_sin;
+ old_axis_slope_angle = axis_slope_angle;
+ axis_slope_angle = axis_slope_angle + iang_sin - rang_sin;
+ if (object_distance != 0.0)
+ ray_height = object_distance * old_axis_slope_angle;
+ object_distance = ray_height / axis_slope_angle;
+ return;
+ }
+ object_distance = object_distance * (to_index / from_index);
+ axis_slope_angle = axis_slope_angle * (from_index / to_index);
+ return;
+ }
+
+ if (radius_of_curvature != 0.0) {
+ if (object_distance == 0.0) {
+ axis_slope_angle = 0.0;
+ iang_sin = ray_height / radius_of_curvature;
+ } else {
+ iang_sin = ((object_distance -
+ radius_of_curvature) / radius_of_curvature) *
+ sin(axis_slope_angle);
+ }
+ iang = asin(iang_sin);
+ rang_sin = (from_index / to_index) * iang_sin;
+ old_axis_slope_angle = axis_slope_angle;
+ axis_slope_angle = axis_slope_angle + iang - asin(rang_sin);
+ sagitta = sin((old_axis_slope_angle + iang) / 2.0);
+ sagitta = 2.0 * radius_of_curvature * sagitta * sagitta;
+ object_distance =
+ ((radius_of_curvature * sin(old_axis_slope_angle + iang)) *
+ cot(axis_slope_angle)) + sagitta;
+ return;
+ }
+
+ rang = -asin((from_index / to_index) * sin(axis_slope_angle));
+ object_distance = object_distance * ((to_index *
+ cos(-rang)) / (from_index *
+ cos
+ (axis_slope_angle)));
+ axis_slope_angle = -rang;
+}
+
+/* Perform ray trace in specific spectral line */
+
+static void trace_line(line, ray_h)
+int line;
+double ray_h;
+{
+ int i;
+
+ object_distance = 0.0;
+ ray_height = ray_h;
+ from_index = 1.0;
+
+ for (i = 1; i <= current_surfaces; i++) {
+ radius_of_curvature = s[i][1];
+ to_index = s[i][2];
+ if (to_index > 1.0)
+ to_index = to_index + ((spectral_line[4] -
+ spectral_line[line]) /
+ (spectral_line[3] -
+ spectral_line[6])) * ((s[i][2] -
+ 1.0) / s[i][3]);
+ transit_surface();
+ from_index = to_index;
+ if (i < current_surfaces)
+ object_distance = object_distance - s[i][4];
+ }
+}
+
+/* Initialise when called the first time */
+
+void fbench()
+{
+ int i, j;
+ double od_fline, od_cline;
+
+ spectral_line[1] = 7621.0; /* A */
+ spectral_line[2] = 6869.955; /* B */
+ spectral_line[3] = 6562.816; /* C */
+ spectral_line[4] = 5895.944; /* D */
+ spectral_line[5] = 5269.557; /* E */
+ spectral_line[6] = 4861.344; /* F */
+ spectral_line[7] = 4340.477; /* G' */
+ spectral_line[8] = 3968.494; /* H */
+
+ /* Load test case into working array */
+
+ clear_aperture = 4.0;
+ current_surfaces = 4;
+ for (i = 0; i < current_surfaces; i++)
+ for (j = 0; j < 4; j++)
+ s[i + 1][j + 1] = testcase[i][j];
+
+ for (itercount = 0; itercount < niter; itercount++) {
+ /* Do main trace in D light */
+
+ paraxial = FALSE;
+
+ trace_line(4, clear_aperture / 2.0);
+ od_sa[0][0] = object_distance;
+ od_sa[0][1] = axis_slope_angle;
+
+ paraxial = TRUE;
+
+ trace_line(4, clear_aperture / 2.0);
+ od_sa[1][0] = object_distance;
+ od_sa[1][1] = axis_slope_angle;
+
+ paraxial = FALSE;
+
+ /* Trace marginal ray in C */
+
+ trace_line(3, clear_aperture / 2.0);
+ od_cline = object_distance;
+
+ /* Trace marginal ray in F */
+
+ trace_line(6, clear_aperture / 2.0);
+ od_fline = object_distance;
+
+ aberr_lspher = od_sa[1][0] - od_sa[0][0];
+ aberr_osc = 1.0 - (od_sa[1][0] * od_sa[1][1]) /
+ (sin(od_sa[0][1]) * od_sa[0][0]);
+ aberr_lchrom = od_fline - od_cline;
+ max_lspher = sin(od_sa[0][1]);
+
+ /* D light */
+
+ max_lspher = 0.0000926 / (max_lspher * max_lspher);
+ max_osc = 0.0025;
+ max_lchrom = max_lspher;
+ }
+}
+
+#ifdef __FBENCH_TEST__
+int main(void)
+{
+ fbench();
+
+ return 0;
+}
+#endif
diff --git a/modules/benchmark/fft.c b/modules/benchmark/fft.c
new file mode 100644
index 00000000..503a7aaf
--- /dev/null
+++ b/modules/benchmark/fft.c
@@ -0,0 +1,70 @@
+/*
+ * HardInfo - System Information and Benchmark
+ * Copyright (C) 2003-2007 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 or later.
+ *
+ * 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"
+#include "fftbench.h"
+
+/* if anything changes in this block, increment revision */
+#define BENCH_REVISION 2
+#define CRUNCH_TIME 5
+
+static gpointer fft_for(void *in_data, gint thread_number)
+{
+ unsigned int i;
+ FFTBench **benches = (FFTBench **)in_data;
+ FFTBench *fftbench = (FFTBench *)(benches[thread_number]);
+
+ fft_bench_run(benches[thread_number]);
+
+ return NULL;
+}
+
+void
+benchmark_fft(void)
+{
+ int cpu_procs, cpu_cores, cpu_threads, cpu_nodes;
+ bench_value r = EMPTY_BENCH_VALUE;
+
+ int n_cores, i;
+ gchar *temp;
+ FFTBench **benches=NULL;
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update("Running FFT benchmark...");
+
+ cpu_procs_cores_threads_nodes(&cpu_procs, &cpu_cores, &cpu_threads, &cpu_nodes);
+
+ /* Pre-allocate all benchmarks */
+ benches = g_new0(FFTBench *, cpu_threads);
+ for (i = 0; i < cpu_threads; i++) {benches[i] = fft_bench_new();}
+
+ /* Run the benchmark */
+ r = benchmark_crunch_for(CRUNCH_TIME, 0, fft_for, benches);
+
+ /* Free up the memory */
+ for (i = 0; i < cpu_threads; i++) {
+ fft_bench_free(benches[i]);
+ }
+ g_free(benches);
+
+ r.result /= 100;
+
+ r.revision = BENCH_REVISION;
+ bench_results[BENCHMARK_FFT] = r;
+}
diff --git a/modules/benchmark/fftbench.c b/modules/benchmark/fftbench.c
new file mode 100644
index 00000000..9449cffd
--- /dev/null
+++ b/modules/benchmark/fftbench.c
@@ -0,0 +1,212 @@
+/*
+ fftbench.c
+
+ Written by Scott Robert Ladd (scott@coyotegulch.com)
+ No rights reserved. This is public domain software, for use by anyone.
+
+ A number-crunching benchmark using LUP-decomposition to solve a large
+ linear equation.
+
+ The code herein is design for the purpose of testing computational
+ performance; error handling is minimal.
+
+ In fact, this is a weak implementation of the FFT; unfortunately, all
+ of my really nifty FFTs are in commercial code, and I haven't had time
+ to write a new FFT routine for this benchmark. I may add a Hartley
+ transform to the seat, too.
+
+ Actual benchmark results can be found at:
+ http://scottrobertladd.net/coyotegulch/
+
+ Please do not use this information or algorithm in any way that might
+ upset the balance of the universe or otherwise cause a disturbance in
+ the space-time continuum.
+*/
+
+#include <time.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+#include "fftbench.h"
+
+// embedded random number generator; ala Park and Miller
+static long seed = 1325;
+static const long IA = 16807;
+static const long IM = 2147483647;
+static const double AM = 4.65661287525E-10;
+static const long IQ = 127773;
+static const long IR = 2836;
+static const long MASK = 123459876;
+
+static double random_double()
+{
+ long k;
+ double result;
+
+ seed ^= MASK;
+ k = seed / IQ;
+ seed = IA * (seed - k * IQ) - IR * k;
+
+ if (seed < 0)
+ seed += IM;
+
+ result = AM * seed;
+ seed ^= MASK;
+
+ return result;
+}
+
+static const int N = 100;
+static const int NM1 = 99; // N - 1
+static const int NP1 = 101; // N + 1
+
+static void lup_decompose(FFTBench *fftbench)
+{
+ int i, j, k, k2, t;
+ double p, temp, **a;
+
+ int *perm = (int *) malloc(sizeof(double) * N);
+
+ fftbench->p = perm;
+ a = fftbench->a;
+
+ for (i = 0; i < N; ++i)
+ perm[i] = i;
+
+ for (k = 0; k < NM1; ++k) {
+ p = 0.0;
+
+ for (i = k; i < N; ++i) {
+ temp = fabs(a[i][k]);
+
+ if (temp > p) {
+ p = temp;
+ k2 = i;
+ }
+ }
+
+ // check for invalid a
+ if (p == 0.0)
+ return;
+
+ // exchange rows
+ t = perm[k];
+ perm[k] = perm[k2];
+ perm[k2] = t;
+
+ for (i = 0; i < N; ++i) {
+ temp = a[k][i];
+ a[k][i] = a[k2][i];
+ a[k2][i] = temp;
+ }
+
+ for (i = k + 1; i < N; ++i) {
+ a[i][k] /= a[k][k];
+
+ for (j = k + 1; j < N; ++j)
+ a[i][j] -= a[i][k] * a[k][j];
+ }
+ }
+}
+
+static double *lup_solve(FFTBench *fftbench)
+{
+ int i, j, j2;
+ double sum, u;
+
+ double *y = (double *) malloc(sizeof(double) * N);
+ double *x = (double *) malloc(sizeof(double) * N);
+
+ double **a = fftbench->a;
+ double *b = fftbench->b;
+ int *perm = fftbench->p;
+
+ for (i = 0; i < N; ++i) {
+ y[i] = 0.0;
+ x[i] = 0.0;
+ }
+
+ for (i = 0; i < N; ++i) {
+ sum = 0.0;
+ j2 = 0;
+
+ for (j = 1; j <= i; ++j) {
+ sum += a[i][j2] * y[j2];
+ ++j2;
+ }
+
+ y[i] = b[perm[i]] - sum;
+ }
+
+ i = NM1;
+
+ while (1) {
+ sum = 0.0;
+ u = a[i][i];
+
+ for (j = i + 1; j < N; ++j)
+ sum += a[i][j] * x[j];
+
+ x[i] = (y[i] - sum) / u;
+
+ if (i == 0)
+ break;
+
+ --i;
+ }
+
+ free(y);
+
+ return x;
+}
+
+FFTBench *fft_bench_new(void)
+{
+ FFTBench *fftbench;
+ int i, j;
+
+ fftbench = g_new0(FFTBench, 1);
+
+ // generate test data
+ fftbench->a = (double **) malloc(sizeof(double *) * N);
+
+ for (i = 0; i < N; ++i) {
+ fftbench->a[i] = (double *) malloc(sizeof(double) * N);
+
+ for (j = 0; j < N; ++j)
+ fftbench->a[i][j] = random_double();
+ }
+
+ fftbench->b = (double *) malloc(sizeof(double) * N);
+
+ for (i = 0; i < N; ++i)
+ fftbench->b[i] = random_double();
+
+ return fftbench;
+}
+
+void fft_bench_run(FFTBench *fftbench)
+{
+ lup_decompose(fftbench);
+ double *x = lup_solve(fftbench);
+ free(x);
+}
+
+void fft_bench_free(FFTBench *fftbench)
+{
+ int i;
+
+ // clean up
+ for (i = 0; i < N; ++i)
+ free(fftbench->a[i]);
+
+ free(fftbench->a);
+ free(fftbench->b);
+ free(fftbench->p);
+ free(fftbench->r);
+
+ g_free(fftbench);
+}
diff --git a/modules/benchmark/fib.c b/modules/benchmark/fib.c
new file mode 100644
index 00000000..2bec8bed
--- /dev/null
+++ b/modules/benchmark/fib.c
@@ -0,0 +1,61 @@
+/*
+ * HardInfo - System Information and Benchmark
+ * Copyright (C) 2003-2007 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 or later.
+ *
+ * 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 "benchmark.h"
+
+/* if anything changes in this block, increment revision */
+#define BENCH_REVISION 2
+#define ANSWER 25
+#define CRUNCH_TIME 5
+
+gulong fib(gulong n)
+{
+ if (n == 0)
+ return 0;
+ else if (n <= 2)
+ return 1;
+ return fib(n - 1) + fib(n - 2);
+}
+
+static gpointer fib_for(void *in_data, gint thread_number)
+{
+ fib(ANSWER);
+
+ return NULL;
+}
+
+
+void
+benchmark_fib(void)
+{
+ GTimer *timer = g_timer_new();
+ bench_value r = EMPTY_BENCH_VALUE;
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update("Calculating Fibonacci number...");
+
+ r = benchmark_crunch_for(CRUNCH_TIME, 0, fib_for, NULL);
+ //r.threads_used = 1;
+
+ r.result /= 100;
+
+ r.revision = BENCH_REVISION;
+ snprintf(r.extra, 255, "a:%d", ANSWER);
+
+ bench_results[BENCHMARK_FIB] = r;
+}
diff --git a/modules/benchmark/guibench.c b/modules/benchmark/guibench.c
new file mode 100644
index 00000000..0faf6b69
--- /dev/null
+++ b/modules/benchmark/guibench.c
@@ -0,0 +1,353 @@
+/*
+ * HardInfo - Displays System Information
+ * 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 or later.
+ *
+ * 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 <gtk/gtk.h>
+
+#include "iconcache.h"
+#include "config.h"
+
+#define N_ITERATIONS 100000
+#define PHRASE "I \342\231\245 HardInfo"
+
+typedef double (*BenchCallback)(GtkWindow *window);
+
+static double test_lines(GtkWindow *window);
+static double test_shapes(GtkWindow *window);
+static double test_filled_shapes(GtkWindow *window);
+static double test_text(GtkWindow *window);
+static double test_icons(GtkWindow *window);
+
+/*
+Results on a AMD Athlon 3200+ (Barton), 1GB RAM,
+nVidia Geforce 6200 with nvidia Xorg driver,
+running Linux 2.6.28, Xorg 1.6.0, Ubuntu 9.04
+desktop, GNOME 2.26.1, composite enabled.
+
+Test Time Iter/Sec
+Line Drawing 3.9570 25271.7663
+Shape Drawing 22.2499 4494.4065
+Filled Shape Drawing 4.0377 24766.2806
+Text Drawing 59.1565 1690.4309
+Icon Blitting 51.720941 1933.4528
+
+Results are normalized according to these values.
+A guibench() result of 1000.0 is roughly equivalent
+to this same setup.
+*/
+
+static struct {
+ BenchCallback callback;
+ gchar *title;
+ gdouble weight;
+} tests[] = {
+ { test_lines, "Line Drawing", 25271.77 },
+ { test_shapes, "Shape Drawing", 4494.49 },
+ { test_filled_shapes, "Filled Shape Drawing", 24766.28 },
+ { test_text, "Text Drawing", 1690.43 },
+ { test_icons, "Icon Blitting", 1933.45 },
+ { NULL, NULL }
+};
+
+static gchar *phrase = NULL;
+
+static gboolean keypress_event(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
+{
+ const int magic[] = { 0x1b, 0x33, 0x3a, 0x35, 0x51 };
+ const int states[] = { 0xff52, 0xff52, 0xff54, 0xff54,
+ 0xff51, 0xff53, 0xff51, 0xff53,
+ 0x62, 0x61 };
+ static int state = 0;
+
+ if (event->keyval == states[state]) {
+ state++;
+ } else {
+ state = 0;
+ }
+
+ if (state == G_N_ELEMENTS(states)) {
+ int i;
+
+ for (i = 0; i < G_N_ELEMENTS(magic); i++) {
+ phrase[i + 6] = magic[i] ^ (states[i] & (states[i] >> 8));
+ }
+
+ state = 0;
+ }
+
+ return FALSE;
+}
+
+static double test_icons(GtkWindow *window)
+{
+ GdkPixbuf *pixbufs[3];
+ GdkGC *gc;
+ GRand *rand;
+ GTimer *timer;
+ double time;
+ GdkWindow *gdk_window = GTK_WIDGET(window)->window;
+ int icons;
+
+ gdk_window_clear(gdk_window);
+
+ rand = g_rand_new();
+ gc = gdk_gc_new(GDK_DRAWABLE(gdk_window));
+ timer = g_timer_new();
+
+ pixbufs[0] = icon_cache_get_pixbuf("hardinfo2.png");
+ pixbufs[1] = icon_cache_get_pixbuf("syncmanager.png");
+ pixbufs[2] = icon_cache_get_pixbuf("report-large.png");
+
+ g_timer_start(timer);
+ for (icons = N_ITERATIONS; icons >= 0; icons--) {
+ int x, y;
+
+ x = g_rand_int_range(rand, 0, 800);
+ y = g_rand_int_range(rand, 0, 600);
+
+ gdk_draw_pixbuf(GDK_DRAWABLE(gdk_window), gc,
+ pixbufs[icons % G_N_ELEMENTS(pixbufs)],
+ 0, 0, x, y, 48, 48,
+ GDK_RGB_DITHER_NONE, 0, 0);
+
+ while (gtk_events_pending()) {
+ gtk_main_iteration();
+ }
+ }
+ g_timer_stop(timer);
+
+ time = g_timer_elapsed(timer, NULL);
+
+ g_rand_free(rand);
+ gdk_gc_destroy(gc);
+ g_timer_destroy(timer);
+
+ return time;
+}
+
+static double test_text(GtkWindow *window)
+{
+ GRand *rand;
+ GTimer *timer;
+ GdkGC *gc;
+ double time;
+ PangoLayout *layout;
+ PangoFontDescription *font;
+ GdkWindow *gdk_window = GTK_WIDGET(window)->window;
+ int strings;
+
+ gdk_window_clear(gdk_window);
+
+ rand = g_rand_new();
+ gc = gdk_gc_new(GDK_DRAWABLE(gdk_window));
+ timer = g_timer_new();
+
+ font = pango_font_description_new();
+ layout = pango_layout_new(gtk_widget_get_pango_context(GTK_WIDGET(window)));
+ pango_layout_set_text(layout, phrase, -1);
+
+ g_timer_start(timer);
+ for (strings = N_ITERATIONS; strings >= 0; strings--) {
+ int x, y, size;
+
+ x = g_rand_int_range(rand, 0, 800);
+ y = g_rand_int_range(rand, 0, 600);
+ size = g_rand_int_range(rand, 1, 96) * PANGO_SCALE;
+
+ pango_font_description_set_size(font, size);
+ pango_layout_set_font_description(layout, font);
+ gdk_draw_layout(GDK_DRAWABLE(gdk_window), gc, x, y, layout);
+
+ gdk_rgb_gc_set_foreground(gc, strings << 8);
+
+ while (gtk_events_pending()) {
+ gtk_main_iteration();
+ }
+
+ }
+ g_timer_stop(timer);
+
+ time = g_timer_elapsed(timer, NULL);
+
+ g_rand_free(rand);
+ gdk_gc_destroy(gc);
+ g_timer_destroy(timer);
+ g_object_unref(layout);
+ pango_font_description_free(font);
+
+ return time;
+}
+
+static double test_filled_shapes(GtkWindow *window)
+{
+ GRand *rand;
+ GTimer *timer;
+ GdkGC *gc;
+ double time;
+ GdkWindow *gdk_window = GTK_WIDGET(window)->window;
+ int lines;
+
+ gdk_window_clear(gdk_window);
+
+ rand = g_rand_new();
+ gc = gdk_gc_new(GDK_DRAWABLE(gdk_window));
+ timer = g_timer_new();
+
+ g_timer_start(timer);
+ for (lines = N_ITERATIONS; lines >= 0; lines--) {
+ int x1, y1;
+
+ x1 = g_rand_int_range(rand, 0, 800);
+ y1 = g_rand_int_range(rand, 0, 600);
+
+ gdk_rgb_gc_set_foreground(gc, lines << 8);
+
+ gdk_draw_rectangle(GDK_DRAWABLE(gdk_window), gc, TRUE,
+ x1, y1,
+ g_rand_int_range(rand, 0, 400),
+ g_rand_int_range(rand, 0, 300));
+
+ while (gtk_events_pending()) {
+ gtk_main_iteration();
+ }
+ }
+ g_timer_stop(timer);
+
+ time = g_timer_elapsed(timer, NULL);
+
+ g_rand_free(rand);
+ gdk_gc_destroy(gc);
+ g_timer_destroy(timer);
+
+ return time;
+}
+
+static double test_shapes(GtkWindow *window)
+{
+ GRand *rand;
+ GTimer *timer;
+ GdkGC *gc;
+ double time;
+ GdkWindow *gdk_window = GTK_WIDGET(window)->window;
+ int lines;
+
+ gdk_window_clear(gdk_window);
+
+ rand = g_rand_new();
+ gc = gdk_gc_new(GDK_DRAWABLE(gdk_window));
+ timer = g_timer_new();
+
+ g_timer_start(timer);
+ for (lines = N_ITERATIONS; lines >= 0; lines--) {
+ int x1, y1;
+
+ x1 = g_rand_int_range(rand, 0, 800);
+ y1 = g_rand_int_range(rand, 0, 600);
+
+ gdk_rgb_gc_set_foreground(gc, lines << 8);
+
+ gdk_draw_rectangle(GDK_DRAWABLE(gdk_window), gc, FALSE,
+ x1, y1,
+ g_rand_int_range(rand, 0, 400),
+ g_rand_int_range(rand, 0, 300));
+ while (gtk_events_pending()) {
+ gtk_main_iteration();
+ }
+ }
+ g_timer_stop(timer);
+
+ time = g_timer_elapsed(timer, NULL);
+
+ g_rand_free(rand);
+ gdk_gc_destroy(gc);
+ g_timer_destroy(timer);
+
+ return time;
+}
+
+static double test_lines(GtkWindow *window)
+{
+ GRand *rand;
+ GTimer *timer;
+ GdkGC *gc;
+ double time;
+ GdkWindow *gdk_window = GTK_WIDGET(window)->window;
+ int lines;
+
+ gdk_window_clear(gdk_window);
+
+ rand = g_rand_new();
+ gc = gdk_gc_new(GDK_DRAWABLE(gdk_window));
+ timer = g_timer_new();
+
+ g_timer_start(timer);
+ for (lines = N_ITERATIONS; lines >= 0; lines--) {
+ int x1, y1, x2, y2;
+
+ x1 = g_rand_int_range(rand, 0, 800);
+ y1 = g_rand_int_range(rand, 0, 600);
+ x2 = g_rand_int_range(rand, 0, 800);
+ y2 = g_rand_int_range(rand, 0, 600);
+
+ gdk_draw_line(GDK_DRAWABLE(gdk_window), gc, x1, y1, x2, y2);
+ gdk_rgb_gc_set_foreground(gc, lines << 8);
+
+ while (gtk_events_pending()) {
+ gtk_main_iteration();
+ }
+ }
+ g_timer_stop(timer);
+
+ time = g_timer_elapsed(timer, NULL);
+
+ g_rand_free(rand);
+ gdk_gc_destroy(gc);
+ g_timer_destroy(timer);
+
+ return time;
+}
+
+double guibench(void)
+{
+ GtkWidget *window;
+ gdouble score = 0.0f;
+ gint i;
+
+ phrase = g_strdup(PHRASE);
+
+ window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_widget_set_size_request(window, 800, 600);
+ gtk_window_set_title(GTK_WINDOW(window), "guibench");
+
+ gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
+ gtk_widget_show(window);
+
+ g_signal_connect(window, "key-press-event", G_CALLBACK(keypress_event), NULL);
+
+ for (i = 0; tests[i].title; i++) {
+ double time;
+
+ gtk_window_set_title(GTK_WINDOW(window), tests[i].title);
+ time = tests[i].callback(GTK_WINDOW(window));
+ score += (N_ITERATIONS / time) / tests[i].weight;
+ }
+
+ gtk_widget_destroy(window);
+ g_free(phrase);
+
+ return (score / i) * 1000.0f;
+}
diff --git a/modules/benchmark/md5.c b/modules/benchmark/md5.c
new file mode 100644
index 00000000..f4032ddd
--- /dev/null
+++ b/modules/benchmark/md5.c
@@ -0,0 +1,317 @@
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest. This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+
+/* This code was modified in 1997 by Jim Kingdon of Cyclic Software to
+ not require an integer type which is exactly 32 bits. This work
+ draws on the changes for the same purpose by Tatu Ylonen
+ <ylo@cs.hut.fi> as part of SSH, but since I didn't actually use
+ that code, there is no copyright issue. I hereby disclaim
+ copyright in any changes I have made; this code remains in the
+ public domain. */
+
+#include <string.h> /* for memcpy() and memset() */
+
+/* Add prototype support. */
+#ifndef PROTO
+#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
+#define PROTO(ARGS) ARGS
+#else
+#define PROTO(ARGS) ()
+#endif
+#endif
+
+#include "md5.h"
+
+#if defined(__OPTIMIZE__)
+#error You must compile this program without "-O". (Or else the benchmark results may be different!)
+#endif
+
+/* Little-endian byte-swapping routines. Note that these do not
+ depend on the size of datatypes such as uint32, nor do they require
+ us to detect the endianness of the machine we are running on. It
+ is possible they should be macros for speed, but I would be
+ surprised if they were a performance bottleneck for MD5. */
+
+static uint32 getu32(addr)
+const unsigned char *addr;
+{
+ return (((((unsigned long) addr[3] << 8) | addr[2]) << 8)
+ | addr[1]) << 8 | addr[0];
+}
+
+static void putu32(data, addr)
+uint32 data;
+unsigned char *addr;
+{
+ addr[0] = (unsigned char) data;
+ addr[1] = (unsigned char) (data >> 8);
+ addr[2] = (unsigned char) (data >> 16);
+ addr[3] = (unsigned char) (data >> 24);
+}
+
+/*
+ * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+void MD5Init(ctx)
+struct MD5Context *ctx;
+{
+ ctx->buf[0] = 0x67452301;
+ ctx->buf[1] = 0xefcdab89;
+ ctx->buf[2] = 0x98badcfe;
+ ctx->buf[3] = 0x10325476;
+
+ ctx->bits[0] = 0;
+ ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+void MD5Update(ctx, buf, len)
+struct MD5Context *ctx;
+unsigned char const *buf;
+unsigned len;
+{
+ uint32 t;
+
+ /* Update bitcount */
+
+ t = ctx->bits[0];
+ if ((ctx->bits[0] = (t + ((uint32) len << 3)) & 0xffffffff) < t)
+ ctx->bits[1]++; /* Carry from low to high */
+ ctx->bits[1] += len >> 29;
+
+ t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
+
+ /* Handle any leading odd-sized chunks */
+
+ if (t) {
+ unsigned char *p = ctx->in + t;
+
+ t = 64 - t;
+ if (len < t) {
+ memcpy(p, buf, len);
+ return;
+ }
+ memcpy(p, buf, t);
+ MD5Transform(ctx->buf, ctx->in);
+ buf += t;
+ len -= t;
+ }
+
+ /* Process data in 64-byte chunks */
+
+ while (len >= 64) {
+ memcpy(ctx->in, buf, 64);
+ MD5Transform(ctx->buf, ctx->in);
+ buf += 64;
+ len -= 64;
+ }
+
+ /* Handle any remaining bytes of data. */
+
+ memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+void MD5Final(digest, ctx)
+unsigned char digest[16];
+struct MD5Context *ctx;
+{
+ unsigned count;
+ unsigned char *p;
+
+ /* Compute number of bytes mod 64 */
+ count = (ctx->bits[0] >> 3) & 0x3F;
+
+ /* Set the first char of padding to 0x80. This is safe since there is
+ always at least one byte free */
+ p = ctx->in + count;
+ *p++ = 0x80;
+
+ /* Bytes of padding needed to make 64 bytes */
+ count = 64 - 1 - count;
+
+ /* Pad out to 56 mod 64 */
+ if (count < 8) {
+ /* Two lots of padding: Pad the first block to 64 bytes */
+ memset(p, 0, count);
+ MD5Transform(ctx->buf, ctx->in);
+
+ /* Now fill the next block with 56 bytes */
+ memset(ctx->in, 0, 56);
+ } else {
+ /* Pad block to 56 bytes */
+ memset(p, 0, count - 8);
+ }
+
+ /* Append length in bits and transform */
+ putu32(ctx->bits[0], ctx->in + 56);
+ putu32(ctx->bits[1], ctx->in + 60);
+
+ MD5Transform(ctx->buf, ctx->in);
+ putu32(ctx->buf[0], digest);
+ putu32(ctx->buf[1], digest + 4);
+ putu32(ctx->buf[2], digest + 8);
+ putu32(ctx->buf[3], digest + 12);
+ memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
+}
+
+#ifndef ASM_MD5
+
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+ ( w += f(x, y, z) + data, w &= 0xffffffff, w = w<<s | w>>(32-s), w += x )
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data. MD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+void MD5Transform(buf, inraw)
+uint32 buf[4];
+const unsigned char inraw[64];
+{
+ register uint32 a, b, c, d;
+ uint32 in[16];
+ int i;
+
+ for (i = 0; i < 16; ++i)
+ in[i] = getu32(inraw + 4 * i);
+
+ a = buf[0];
+ b = buf[1];
+ c = buf[2];
+ d = buf[3];
+
+ MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+ MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+ MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+ MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+ MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+ MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+ MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+ MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+ MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+ MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+ MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+ MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+ MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+ MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+ MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+ MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+ MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+ MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+ MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+ MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+ MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+ MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+ MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+ MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+ MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+ MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+ MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+ MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+ MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+ MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+ MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+ MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+ MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+ MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+ MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+ MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+ MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+ MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+ MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+ MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+ MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+ MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+ MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+ MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+ MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+ MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+ MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+ MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+ MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+ MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+ MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+ MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+ MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+ MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+ MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+ MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+ MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+ MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+ MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+ MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+ MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+ MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+ MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+ MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+ buf[0] += a;
+ buf[1] += b;
+ buf[2] += c;
+ buf[3] += d;
+}
+#endif
+
+#ifdef TEST
+/* Simple test program. Can use it to manually run the tests from
+ RFC1321 for example. */
+#include <stdio.h>
+
+int main(int argc, char **argv)
+{
+ struct MD5Context context;
+ unsigned char checksum[16];
+ int i;
+ int j;
+
+ if (argc < 2) {
+ fprintf(stderr, "usage: %s string-to-hash\n", argv[0]);
+ exit(1);
+ }
+ for (j = 1; j < argc; ++j) {
+ printf("MD5 (\"%s\") = ", argv[j]);
+ MD5Init(&context);
+ MD5Update(&context, argv[j], strlen(argv[j]));
+ MD5Final(checksum, &context);
+ for (i = 0; i < 16; i++) {
+ printf("%02x", (unsigned int) checksum[i]);
+ }
+ printf("\n");
+ }
+ return 0;
+}
+#endif /* TEST */
diff --git a/modules/benchmark/nqueens.c b/modules/benchmark/nqueens.c
new file mode 100644
index 00000000..6aad7638
--- /dev/null
+++ b/modules/benchmark/nqueens.c
@@ -0,0 +1,68 @@
+/*
+ * N-Queens Problem Solver
+ * Found somewhere on the Internet; can't remember where. Possibly Wikipedia.
+ */
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include "hardinfo.h"
+#include "benchmark.h"
+
+/* if anything changes in this block, increment revision */
+#define BENCH_REVISION 2
+#define QUEENS 6
+#define CRUNCH_TIME 5
+
+int row[QUEENS];
+
+bool safe(int x, int y) {
+ int i;
+ for (i = 1; i <= y; i++)
+ if (row[y - i] == x || row[y - i] == x - i || row[y - i] == x + i)
+ return false;
+ return true;
+}
+
+int nqueens(int y) {
+ int x;
+
+ for (x = 0; x < QUEENS; x++) {
+ if (safe((row[y - 1] = x), y - 1)) {
+ if (y < QUEENS) {
+ nqueens(y + 1);
+ } else {
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static gpointer nqueens_for(void *data, gint thread_number)
+{
+ nqueens(0);
+
+ return NULL;
+}
+
+void
+benchmark_nqueens(void)
+{
+ bench_value r = EMPTY_BENCH_VALUE;
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update("Running N-Queens benchmark...");
+
+ r = benchmark_crunch_for(CRUNCH_TIME, 0, nqueens_for, NULL);
+
+ r.revision = BENCH_REVISION;
+ snprintf(r.extra, 255, "q:%d", QUEENS);
+
+ r.result /= 25;
+
+ bench_results[BENCHMARK_NQUEENS] = r;
+}
+
+
diff --git a/modules/benchmark/raytrace.c b/modules/benchmark/raytrace.c
new file mode 100644
index 00000000..bddc3232
--- /dev/null
+++ b/modules/benchmark/raytrace.c
@@ -0,0 +1,56 @@
+/*
+ * HardInfo - System Information and Benchmark
+ * Copyright (C) 2003-2007 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 or later.
+ *
+ * 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 "benchmark.h"
+
+/* if anything changes in this block, increment revision */
+#define BENCH_REVISION 2
+#define CRUNCH_TIME 5
+
+void fbench(); /* fbench.c */
+
+static gpointer parallel_raytrace(void *in_data, gint thread_number)
+{
+ unsigned int i;
+
+ fbench();
+
+ return NULL;
+}
+
+void
+benchmark_raytrace(void)
+{
+ bench_value r = EMPTY_BENCH_VALUE;
+ gchar *test_data = get_test_data(1000);
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update("Performing John Walker's FBENCH...");
+
+ r = benchmark_crunch_for(CRUNCH_TIME, 1, parallel_raytrace, test_data);
+
+ r.revision = BENCH_REVISION;
+ snprintf(r.extra, 255, "r:%d", 500);//niter from fbench
+
+ g_free(test_data);
+
+ r.result /= 10;
+
+ bench_results[BENCHMARK_RAYTRACE] = r;
+}
+
diff --git a/modules/benchmark/sha1.c b/modules/benchmark/sha1.c
new file mode 100644
index 00000000..3b213218
--- /dev/null
+++ b/modules/benchmark/sha1.c
@@ -0,0 +1,329 @@
+/*
+SHA-1 in C
+By Steve Reid <steve@edmweb.com>
+100% Public Domain
+
+Test Vectors (from FIPS PUB 180-1)
+"abc"
+ A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+ 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
+A million repetitions of "a"
+ 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
+*/
+
+
+/* #define SHA1HANDSOFF * Copies data before messing with it. */
+
+#include <stdio.h>
+#include <string.h>
+#include <sha1.h>
+
+#if defined(__OPTIMIZE__)
+#error You must compile this program without "-O".
+#endif
+
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+#ifdef LITTLE_ENDIAN
+#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
+ |(rol(block->l[i],8)&0x00FF00FF))
+#else
+#define blk0(i) block->l[i]
+#endif
+#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
+ ^block->l[(i+2)&15]^block->l[i&15],1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
+#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
+
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+
+void SHA1Transform(guint32 state[20], guchar buffer[64])
+{
+ guint32 a, b, c, d, e;
+ typedef union {
+ guchar c[64];
+ guint32 l[16];
+ } CHAR64LONG16;
+ CHAR64LONG16 *block;
+#ifdef SHA1HANDSOFF
+ static guchar workspace[64];
+ block = (CHAR64LONG16 *) workspace;
+ memcpy(block, buffer, 64);
+#else
+ block = (CHAR64LONG16 *) buffer;
+#endif
+ /* Copy context->state[] to working vars */
+ a = state[0];
+ b = state[1];
+ c = state[2];
+ d = state[3];
+ e = state[4];
+ /* 4 rounds of 20 operations each. Loop unrolled. */
+ R0(a, b, c, d, e, 0);
+ R0(e, a, b, c, d, 1);
+ R0(d, e, a, b, c, 2);
+ R0(c, d, e, a, b, 3);
+ R0(b, c, d, e, a, 4);
+ R0(a, b, c, d, e, 5);
+ R0(e, a, b, c, d, 6);
+ R0(d, e, a, b, c, 7);
+ R0(c, d, e, a, b, 8);
+ R0(b, c, d, e, a, 9);
+ R0(a, b, c, d, e, 10);
+ R0(e, a, b, c, d, 11);
+ R0(d, e, a, b, c, 12);
+ R0(c, d, e, a, b, 13);
+ R0(b, c, d, e, a, 14);
+ R0(a, b, c, d, e, 15);
+ R1(e, a, b, c, d, 16);
+ R1(d, e, a, b, c, 17);
+ R1(c, d, e, a, b, 18);
+ R1(b, c, d, e, a, 19);
+ R2(a, b, c, d, e, 20);
+ R2(e, a, b, c, d, 21);
+ R2(d, e, a, b, c, 22);
+ R2(c, d, e, a, b, 23);
+ R2(b, c, d, e, a, 24);
+ R2(a, b, c, d, e, 25);
+ R2(e, a, b, c, d, 26);
+ R2(d, e, a, b, c, 27);
+ R2(c, d, e, a, b, 28);
+ R2(b, c, d, e, a, 29);
+ R2(a, b, c, d, e, 30);
+ R2(e, a, b, c, d, 31);
+ R2(d, e, a, b, c, 32);
+ R2(c, d, e, a, b, 33);
+ R2(b, c, d, e, a, 34);
+ R2(a, b, c, d, e, 35);
+ R2(e, a, b, c, d, 36);
+ R2(d, e, a, b, c, 37);
+ R2(c, d, e, a, b, 38);
+ R2(b, c, d, e, a, 39);
+ R3(a, b, c, d, e, 40);
+ R3(e, a, b, c, d, 41);
+ R3(d, e, a, b, c, 42);
+ R3(c, d, e, a, b, 43);
+ R3(b, c, d, e, a, 44);
+ R3(a, b, c, d, e, 45);
+ R3(e, a, b, c, d, 46);
+ R3(d, e, a, b, c, 47);
+ R3(c, d, e, a, b, 48);
+ R3(b, c, d, e, a, 49);
+ R3(a, b, c, d, e, 50);
+ R3(e, a, b, c, d, 51);
+ R3(d, e, a, b, c, 52);
+ R3(c, d, e, a, b, 53);
+ R3(b, c, d, e, a, 54);
+ R3(a, b, c, d, e, 55);
+ R3(e, a, b, c, d, 56);
+ R3(d, e, a, b, c, 57);
+ R3(c, d, e, a, b, 58);
+ R3(b, c, d, e, a, 59);
+ R4(a, b, c, d, e, 60);
+ R4(e, a, b, c, d, 61);
+ R4(d, e, a, b, c, 62);
+ R4(c, d, e, a, b, 63);
+ R4(b, c, d, e, a, 64);
+ R4(a, b, c, d, e, 65);
+ R4(e, a, b, c, d, 66);
+ R4(d, e, a, b, c, 67);
+ R4(c, d, e, a, b, 68);
+ R4(b, c, d, e, a, 69);
+ R4(a, b, c, d, e, 70);
+ R4(e, a, b, c, d, 71);
+ R4(d, e, a, b, c, 72);
+ R4(c, d, e, a, b, 73);
+ R4(b, c, d, e, a, 74);
+ R4(a, b, c, d, e, 75);
+ R4(e, a, b, c, d, 76);
+ R4(d, e, a, b, c, 77);
+ R4(c, d, e, a, b, 78);
+ R4(b, c, d, e, a, 79);
+ /* Add the working vars back into context.state[] */
+ state[0] += a;
+ state[1] += b;
+ state[2] += c;
+ state[3] += d;
+ state[4] += e;
+ /* Wipe variables */
+ a = b = c = d = e = 0;
+}
+
+
+/* SHA1Init - Initialize new context */
+
+void SHA1Init(SHA1_CTX * context)
+{
+ /* SHA1 initialization constants */
+ context->state[0] = 0x67452301;
+ context->state[1] = 0xEFCDAB89;
+ context->state[2] = 0x98BADCFE;
+ context->state[3] = 0x10325476;
+ context->state[4] = 0xC3D2E1F0;
+ context->count[0] = context->count[1] = 0;
+}
+
+
+/* Run your data through this. */
+
+void SHA1Update(SHA1_CTX * context, guchar * data, guint32 len)
+{
+ guint32 i, j;
+
+ j = (context->count[0] >> 3) & 63;
+ if ((context->count[0] += len << 3) < (len << 3))
+ context->count[1]++;
+ context->count[1] += (len >> 29);
+ if ((j + len) > 63) {
+ memcpy(&context->buffer[j], data, (i = 64 - j));
+ SHA1Transform(context->state, context->buffer);
+ for (; i + 63 < len; i += 64) {
+ SHA1Transform(context->state, &data[i]);
+ }
+ j = 0;
+ } else
+ i = 0;
+ memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+
+/* Add padding and return the message digest. */
+
+void SHA1Final(guchar digest[20], SHA1_CTX * context)
+{
+ guint32 i, j;
+ guchar finalcount[8];
+
+ for (i = 0; i < 8; i++) {
+ finalcount[i] = (guchar) ((context->count[(i >= 4 ? 0 : 1)]
+ >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
+ }
+ SHA1Update(context, (guchar *) "\200", 1);
+ while ((context->count[0] & 504) != 448) {
+ SHA1Update(context, (guchar *) "\0", 1);
+ }
+ SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
+ for (i = 0; i < 20; i++) {
+ digest[i] = (guchar)
+ ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
+ }
+ /* Wipe variables */
+ i = j = 0;
+ memset(context->buffer, 0, 64);
+ memset(context->state, 0, 20);
+ memset(context->count, 0, 8);
+ memset(&finalcount, 0, 8);
+#ifdef SHA1HANDSOFF /* make SHA1Transform overwrite it's own static vars */
+ SHA1Transform(context->state, context->buffer);
+#endif
+}
+
+#ifdef SHA1_TEST
+static char *b32_alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+static void base32_encode_exactly(guchar * buf, gint len,
+ guchar * encbuf, gint enclen)
+{
+ gint i = 0;
+ guchar *ip = buf + len;
+ guchar *op = encbuf + enclen;
+
+ switch (len % 5) {
+ case 0:
+ do {
+ g_assert(op - encbuf >= 8);
+ i = *--ip; /* Input #4 */
+ *--op = b32_alphabet[i & 0x1f]; /* Ouput #7 */
+ i >>= 5; /* upper <234>, input #4 */
+ /* FALLTHROUGH */
+ case 4:
+ i |= ((guint32) * --ip) << 3; /* had 3 bits in `i' */
+ *--op = b32_alphabet[i & 0x1f]; /* Output #6 */
+ i >>= 5; /* upper <401234>, input #3 */
+ *--op = b32_alphabet[i & 0x1f]; /* Output #5 */
+ i >>= 5; /* upper <4>, input #3 */
+ /* FALLTHROUGH */
+ case 3:
+ i |= ((guint32) * --ip) << 1; /* had 1 bits in `i' */
+ *--op = b32_alphabet[i & 0x1f]; /* Output #4 */
+ i >>= 5; /* upper <1234>, input #2 */
+ /* FALLTHROUGH */
+ case 2:
+ i |= ((guint32) * --ip) << 4; /* had 4 bits in `i' */
+ *--op = b32_alphabet[i & 0x1f]; /* Output #3 */
+ i >>= 5; /* upper <3401234>, input #1 */
+ *--op = b32_alphabet[i & 0x1f]; /* Output #2 */
+ i >>= 5; /* upper <34>, input #1 */
+ /* FALLTHROUGH */
+ case 1:
+ i |= ((guint32) * --ip) << 2; /* had 2 bits in `i' */
+ *--op = b32_alphabet[i & 0x1f]; /* Output #1 */
+ i >>= 5; /* upper <01234>, input #0 */
+ *--op = b32_alphabet[i & 0x1f]; /* Output #0 */
+ i >>= 5; /* Holds nothing, MBZ */
+ g_assert(i == 0);
+ g_assert(op >= encbuf);
+ } while (op > encbuf);
+ }
+}
+
+
+
+/*************************************************************/
+
+int main(int argc, char **argv)
+{
+ gint i, j;
+ SHA1_CTX context;
+ guchar digest[20], buffer[16384];
+ FILE *file;
+
+ if (argc > 2) {
+ puts("Public domain SHA-1 implementation - by Steve Reid <steve@edmweb.com>");
+ puts("Produces the SHA-1 hash of a file, or stdin if no file is specified.");
+ exit(0);
+ }
+ if (argc < 2) {
+ file = stdin;
+ } else {
+ if (!(file = fopen(argv[1], "rb"))) {
+ fputs("Unable to open file.", stderr);
+ exit(-1);
+ }
+ }
+ SHA1Init(&context);
+ while (!feof(file)) { /* note: what if ferror(file) */
+ i = fread(buffer, 1, 16384, file);
+ SHA1Update(&context, buffer, i);
+ }
+ SHA1Final(digest, &context);
+ fclose(file);
+
+ for (i = 0; i < 5; i++) {
+ for (j = 0; j < 4; j++) {
+ printf("%02X", digest[i*4+j]);
+ }
+ putchar(' ');
+ }
+ putchar('\n');
+
+ {
+ guchar tmp[33];
+ tmp[32] = '\0';
+ base32_encode_exactly(digest, 20, tmp, 32);
+ printf("%s\n", tmp);
+ }
+
+ exit(0);
+}
+#endif /* SHA1_TEST */
diff --git a/modules/benchmark/sysbench.c b/modules/benchmark/sysbench.c
new file mode 100644
index 00000000..5c45831d
--- /dev/null
+++ b/modules/benchmark/sysbench.c
@@ -0,0 +1,270 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2017 L. A. F. Pereira <l@tia.mat.br>
+ * 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 or later.
+ *
+ * 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"
+#include "cpu_util.h"
+
+#define STATMSG "Performing Alexey Kopytov's sysbench memory benchmark"
+
+/* known to work with:
+ * sysbench 0.4.12 --> r:4012
+ * sysbench 1.0.11 --> r:1000011
+ * sysbench 1.0.15 --> r:1000015
+ */
+
+struct sysbench_ctx {
+ char *test;
+ int threads;
+ int max_time;
+ char *parms_test;
+ bench_value r;
+};
+
+int sysbench_version() {
+ int ret = -1;
+ int v1 = 0, v2 = 0, v3 = 0, mc = 0;
+ gboolean spawned;
+ gchar *out, *err, *p, *next_nl;
+
+ spawned = g_spawn_command_line_sync("sysbench --version",
+ &out, &err, NULL, NULL);
+ if (spawned) {
+ ret = 0;
+ 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) {
+ ret += v1 * 1000000;
+ ret += v2 * 1000;
+ ret += v3;
+ break;
+ }
+ p = next_nl + 1;
+ }
+ g_free(out);
+ g_free(err);
+ }
+ return ret;
+}
+
+static gboolean sysbench_run(struct sysbench_ctx *ctx, int expecting_version) {
+ 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_test) return FALSE;
+ if (!ctx->threads) ctx->threads = 1;
+ ctx->r.threads_used = ctx->threads;
+ if (!ctx->max_time) ctx->max_time = 7;
+
+ gchar *cmd_line = NULL;
+ snprintf(ctx->r.extra, 255, "--time=%d %s", ctx->max_time, ctx->parms_test);
+ util_compress_space(ctx->r.extra);
+
+ if (!expecting_version)
+ expecting_version = sysbench_version();
+ if (expecting_version < 1000000) {
+ /* v0.x.x: sysbench [general-options]... --test=<test-name> [test-options]... command */
+ cmd_line = g_strdup_printf("sysbench --num-threads=%d --max-time=%d --test=%s %s run", ctx->threads, ctx->max_time, ctx->test, ctx->parms_test);
+ } else {
+ /* v1.x.x: sysbench [options]... [testname] [command] */
+ cmd_line = g_strdup_printf("sysbench --threads=%d --time=%d %s %s run", ctx->threads, ctx->max_time, ctx->parms_test, ctx->test);
+ }
+ //bench_msg("\ncmd_line: %s", cmd_line);
+
+ spawned = g_spawn_command_line_sync(cmd_line,
+ &out, &err, NULL, NULL);
+ g_free(cmd_line);
+ if (spawned) {
+ p = out;
+ while(next_nl = strchr(p, '\n')) {
+ *next_nl = 0;
+
+ if (strstr(p, "Usage:")) {
+ /* We're hosed */
+ goto sysbench_failed;
+ }
+
+ /* 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);
+ }
+ }
+ if (SEQ(ctx->test, "cpu") ) {
+ if (ctx->r.revision < 1000000) {
+ // there is not a nice result line
+ // to grab in version 0.x...
+ // total time: 7.0016s
+ // total number of events: 873
+
+ /* should already have "total time:" */
+ if (pp = strstr(p, " total number of events:")) {
+ pp = strchr(pp, ':') + 1;
+ ctx->r.result = strtof(pp, NULL);
+ ctx->r.result /= ctx->r.elapsed_time;
+ }
+ }
+ if (ctx->r.revision >= 1000000) {
+ // events per second: 1674.97
+ if (pp = strstr(p, " events per second:")) {
+ pp = strchr(pp, ':') + 1;
+ ctx->r.result = strtof(pp, NULL);
+ }
+ }
+ }
+
+ p = next_nl + 1;
+ }
+ g_free(out);
+ g_free(err);
+ } else {
+ bench_msg("\nfailed to spawn sysbench");
+ sleep(5);
+ }
+
+ if (ctx->r.result == -1)
+ goto sysbench_failed;
+
+ return spawned;
+
+sysbench_failed:
+ bench_msg("\nfailed to configure sysbench");
+ g_free(out);
+ g_free(err);
+ return 0;
+}
+
+void benchmark_memory_run(int threads, int result_index) {
+ int cpu_procs, cpu_cores, cpu_threads, cpu_nodes;
+
+ cpu_procs_cores_threads_nodes(&cpu_procs, &cpu_cores, &cpu_threads, &cpu_nodes);
+
+ struct sysbench_ctx ctx = {
+ .test = "memory",
+ .threads = threads>0 ? threads : cpu_threads,
+ .parms_test = "",
+ .r = EMPTY_BENCH_VALUE};
+
+ int sbv = sysbench_version();
+ if (BENCH_PTR_BITS > 32 && sbv >= 1000011) {
+ ctx.parms_test =
+ " --memory-block-size=1K"
+ " --memory-total-size=100G"
+ " --memory-scope=global"
+ " --memory-hugetlb=off"
+ " --memory-oper=write"
+ " --memory-access-mode=seq";
+ } else {
+ /* safer set */
+ ctx.parms_test =
+ " --memory-block-size=1K"
+ " --memory-total-size=3056M"
+ " --memory-scope=global"
+ " --memory-hugetlb=off"
+ " --memory-oper=write"
+ " --memory-access-mode=seq";
+ }
+
+ shell_view_set_enabled(FALSE);
+ char msg[128] = "";
+ snprintf(msg, 128, "%s (threads: %d)", STATMSG, threads);
+ shell_status_update(msg);
+
+ sysbench_run(&ctx, sbv);
+ bench_results[result_index] = ctx.r;
+}
+
+void benchmark_memory_single(void) { benchmark_memory_run(1, BENCHMARK_MEMORY_SINGLE); }
+void benchmark_memory_dual(void) { benchmark_memory_run(2, BENCHMARK_MEMORY_DUAL); }
+void benchmark_memory_quad(void) { benchmark_memory_run(4, BENCHMARK_MEMORY_QUAD); }
+void benchmark_memory_all(void) { benchmark_memory_run(0, BENCHMARK_MEMORY_ALL); }
+
+void benchmark_sbcpu_single(void) {
+ struct sysbench_ctx ctx = {
+ .test = "cpu",
+ .threads = 1,
+ .parms_test =
+ "--cpu-max-prime=10000",
+ .r = EMPTY_BENCH_VALUE};
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update(STATMSG " (single thread)...");
+
+ sysbench_run(&ctx, 0);
+ bench_results[BENCHMARK_SBCPU_SINGLE] = ctx.r;
+}
+
+void benchmark_sbcpu_all(void) {
+ int cpu_procs, cpu_cores, cpu_threads, cpu_nodes;
+
+ cpu_procs_cores_threads_nodes(&cpu_procs, &cpu_cores, &cpu_threads, &cpu_nodes);
+
+ struct sysbench_ctx ctx = {
+ .test = "cpu",
+ .threads = cpu_threads,
+ .parms_test =
+ "--cpu-max-prime=10000",
+ .r = EMPTY_BENCH_VALUE};
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update(STATMSG " (Multi-thread)...");
+
+ sysbench_run(&ctx, 0);
+ bench_results[BENCHMARK_SBCPU_ALL] = ctx.r;
+}
+
+void benchmark_sbcpu_quad(void) {
+ struct sysbench_ctx ctx = {
+ .test = "cpu",
+ .threads = 4,
+ .parms_test =
+ "--cpu-max-prime=10000",
+ .r = EMPTY_BENCH_VALUE};
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update(STATMSG " (Four thread)...");
+
+ sysbench_run(&ctx, 0);
+ bench_results[BENCHMARK_SBCPU_QUAD] = ctx.r;
+}
diff --git a/modules/benchmark/zlib.c b/modules/benchmark/zlib.c
new file mode 100644
index 00000000..2045969f
--- /dev/null
+++ b/modules/benchmark/zlib.c
@@ -0,0 +1,88 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2017 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 or later.
+ *
+ * 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 <glib.h>
+#include <stdlib.h>
+#include <zlib.h>
+
+#include "benchmark.h"
+
+/* zip/unzip 256KB blocks for 7 seconds
+ * result is number of full completions / 100 */
+
+/* if anything changes in this block, increment revision */
+#define BENCH_REVISION 3
+#define BENCH_DATA_SIZE 262144
+#define BENCH_DATA_MD5 "3753b649c4fa9ea4576fc8f89a773de2"
+#define CRUNCH_TIME 7
+#define VERIFY_RESULT 1
+
+static unsigned int zlib_errors = 0;
+
+static gpointer zlib_for(void *in_data, gint thread_number) {
+ char *compressed;
+ uLong bound = compressBound(BENCH_DATA_SIZE);
+ unsigned int i;
+
+ compressed = malloc(bound);
+ if (!compressed)
+ return NULL;
+
+ char uncompressed[BENCH_DATA_SIZE];
+ uLong compressedBound = bound;
+ uLong destBound = sizeof(uncompressed);
+
+ compress(compressed, &compressedBound, in_data, BENCH_DATA_SIZE);
+ uncompress(uncompressed, &destBound, compressed, compressedBound);
+ if (VERIFY_RESULT) {
+ int cr = memcmp(in_data, uncompressed, BENCH_DATA_SIZE);
+ if (!!cr) {
+ zlib_errors++;
+ bench_msg("zlib error: uncompressed != original");
+ }
+ }
+
+ free(compressed);
+
+ return NULL;
+}
+
+void
+benchmark_zlib(void)
+{
+ bench_value r = EMPTY_BENCH_VALUE;
+ gchar *test_data = get_test_data(BENCH_DATA_SIZE);
+ if (!test_data)
+ return;
+
+ shell_view_set_enabled(FALSE);
+ shell_status_update("Running Zlib benchmark...");
+
+ gchar *d = md5_digest_str(test_data, BENCH_DATA_SIZE);
+ if (!SEQ(d, BENCH_DATA_MD5))
+ bench_msg("test data has different md5sum: expected %s, actual %s", BENCH_DATA_MD5, d);
+
+ r = benchmark_crunch_for(CRUNCH_TIME, 0, zlib_for, test_data);
+ r.result /= 100;
+ r.revision = BENCH_REVISION;
+ snprintf(r.extra, 255, "zlib %s (built against: %s), d:%s, e:%d", zlib_version, ZLIB_VERSION, d, zlib_errors);
+ bench_results[BENCHMARK_ZLIB] = r;
+
+ g_free(test_data);
+ g_free(d);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-06 15:35:12 +0000