1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
/*
* HardInfo - Displays System Information
* Copyright (C) 2003-2017 Leandro A. F. Pereira <leandro@hardinfo.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 2.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/* 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); \
}
/* lower is better R = 0 */
BENCH_CALLBACK(callback_fib, "CPU Fibonacci", BENCHMARK_FIB, 0);
BENCH_CALLBACK(callback_nqueens, "CPU N-Queens", BENCHMARK_NQUEENS, 0);
BENCH_CALLBACK(callback_fft, "FPU FFT", BENCHMARK_FFT, 0);
BENCH_CALLBACK(callback_raytr, "FPU Raytracing", BENCHMARK_RAYTRACE, 0);
/* higher is better R = 1 */
BENCH_CALLBACK(callback_bfsh_single, "CPU Blowfish (Single-thread)", BENCHMARK_BLOWFISH_SINGLE, 1);
BENCH_CALLBACK(callback_bfsh_threads, "CPU Blowfish (Multi-thread)", BENCHMARK_BLOWFISH_THREADS, 1);
BENCH_CALLBACK(callback_bfsh_cores, "CPU Blowfish (Multi-core)", BENCHMARK_BLOWFISH_CORES, 1);
BENCH_CALLBACK(callback_memory_single, "Memory (Single)", BENCHMARK_MEMORY_SINGLE, 1);
BENCH_CALLBACK(callback_memory_dual, "Memory (Double)", BENCHMARK_MEMORY_DUAL, 1);
BENCH_CALLBACK(callback_memory_quad, "Memory (Quad)", BENCHMARK_MEMORY_QUAD, 1);
BENCH_CALLBACK(callback_cryptohash, "CPU CryptoHash", BENCHMARK_CRYPTOHASH, 1);
BENCH_CALLBACK(callback_zlib, "CPU Zlib", BENCHMARK_ZLIB, 1);
BENCH_CALLBACK(callback_gui, "GPU Drawing", BENCHMARK_GUI, 1);
#define BENCH_SCAN_SIMPLE(SN, BF, BID) \
void SN(gboolean reload) { \
SCAN_START(); \
do_benchmark(BF, BID); \
SCAN_END(); \
}
BENCH_SCAN_SIMPLE(scan_fft, benchmark_fft, BENCHMARK_FFT);
BENCH_SCAN_SIMPLE(scan_nqueens, benchmark_nqueens, BENCHMARK_NQUEENS);
BENCH_SCAN_SIMPLE(scan_raytr, benchmark_raytrace, BENCHMARK_RAYTRACE);
BENCH_SCAN_SIMPLE(scan_bfsh_single, benchmark_bfish_single, BENCHMARK_BLOWFISH_SINGLE);
BENCH_SCAN_SIMPLE(scan_bfsh_threads, benchmark_bfish_threads, BENCHMARK_BLOWFISH_THREADS);
BENCH_SCAN_SIMPLE(scan_bfsh_cores, benchmark_bfish_cores, BENCHMARK_BLOWFISH_CORES);
BENCH_SCAN_SIMPLE(scan_memory_single, benchmark_memory_single, BENCHMARK_MEMORY_SINGLE);
BENCH_SCAN_SIMPLE(scan_memory_dual, benchmark_memory_dual, BENCHMARK_MEMORY_DUAL);
BENCH_SCAN_SIMPLE(scan_memory_quad, benchmark_memory_quad, BENCHMARK_MEMORY_QUAD);
BENCH_SCAN_SIMPLE(scan_cryptohash, benchmark_cryptohash, BENCHMARK_CRYPTOHASH);
BENCH_SCAN_SIMPLE(scan_fib, benchmark_fib, BENCHMARK_FIB);
BENCH_SCAN_SIMPLE(scan_zlib, benchmark_zlib, BENCHMARK_ZLIB);
#if !GTK_CHECK_VERSION(3,0,0)
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[] = {
{N_("CPU Blowfish (Single-thread)"), "blowfish.png", callback_bfsh_single, scan_bfsh_single, MODULE_FLAG_NONE},
{N_("CPU Blowfish (Multi-thread)"), "blowfish.png", callback_bfsh_threads, scan_bfsh_threads, MODULE_FLAG_NONE},
{N_("CPU Blowfish (Multi-core)"), "blowfish.png", callback_bfsh_cores, scan_bfsh_cores, MODULE_FLAG_NONE},
{N_("CPU Zlib"), "file-roller.png", callback_zlib, scan_zlib, MODULE_FLAG_NONE},
{N_("CPU CryptoHash"), "cryptohash.png", callback_cryptohash, scan_cryptohash, MODULE_FLAG_NONE},
{N_("CPU Fibonacci"), "nautilus.png", callback_fib, scan_fib, MODULE_FLAG_NONE},
{N_("CPU N-Queens"), "nqueens.png", callback_nqueens, scan_nqueens, MODULE_FLAG_NONE},
{N_("FPU FFT"), "fft.png", callback_fft, scan_fft, MODULE_FLAG_NONE},
{N_("FPU Raytracing"), "raytrace.png", callback_raytr, scan_raytr, MODULE_FLAG_NONE},
{N_("SysBench Memory (Single-thread)"), "memory.png", callback_memory_single, scan_memory_single, MODULE_FLAG_NONE},
{N_("SysBench Memory (Two threads)"), "memory.png", callback_memory_dual, scan_memory_dual, MODULE_FLAG_NONE},
{N_("SysBench Memory (Four threads)"), "memory.png", callback_memory_quad, scan_memory_quad, MODULE_FLAG_NONE},
#if !GTK_CHECK_VERSION(3,0,0)
{N_("GPU Drawing"), "module.png", callback_gui, scan_gui, MODULE_FLAG_NO_REMOTE},
#endif
{NULL}
};
const gchar *hi_note_func(gint entry)
{
switch (entry) {
case BENCHMARK_MEMORY_SINGLE:
case BENCHMARK_MEMORY_DUAL:
case BENCHMARK_MEMORY_QUAD:
return _("Alexey Kopytov's <i><b>sysbench</b></i> is required.\n"
"Results in MiB/second. Higher is better.");
case BENCHMARK_CRYPTOHASH:
return _("Results in MiB/second. Higher is better.");
case BENCHMARK_BLOWFISH_SINGLE:
case BENCHMARK_BLOWFISH_THREADS:
case BENCHMARK_BLOWFISH_CORES:
case BENCHMARK_ZLIB:
case BENCHMARK_GUI:
return _("Results in HIMarks. Higher is better.");
case BENCHMARK_FFT:
case BENCHMARK_RAYTRACE:
case BENCHMARK_FIB:
case BENCHMARK_NQUEENS:
return _("Results in seconds. Lower is better.");
}
return NULL;
}
|
