dea9b975f8
* Integrated embedded config parsing #245 * cleanup * Cleanup in remotelog * Fixed MS Visual Studio 2019 compatibility * Embedded config parsing only for miner not server * wip * Finished delete template * WIP * Integrated Argon2id/chukwa algo * Added chukwa-wrkz algo variant * Cleanup argon2-512 (chukwa/trtl) and argon2-256 (wrkz) parsing * WIP other argon2 coins * Cleanup and donate fix
120 lines
3.1 KiB
C
120 lines
3.1 KiB
C
#include <time.h>
|
|
#include <string.h>
|
|
|
|
#include "impl-select.h"
|
|
|
|
#include "argon2.h"
|
|
|
|
#define log_maybe(file, ...) \
|
|
do { \
|
|
if (file) { \
|
|
fprintf(file, __VA_ARGS__); \
|
|
} \
|
|
} while((void)0, 0)
|
|
|
|
#define BENCH_SAMPLES 512
|
|
#define BENCH_MEM_BLOCKS 512
|
|
|
|
static argon2_impl selected_argon_impl = {
|
|
"(default)", NULL, fill_segment_default
|
|
};
|
|
|
|
/* the benchmark routine is not thread-safe, so we can use a global var here: */
|
|
static block memory[BENCH_MEM_BLOCKS];
|
|
|
|
static uint64_t benchmark_impl(const argon2_impl *impl) {
|
|
clock_t time;
|
|
unsigned int i;
|
|
uint64_t bench;
|
|
argon2_instance_t instance;
|
|
argon2_position_t pos;
|
|
|
|
memset(memory, 0, sizeof(memory));
|
|
|
|
instance.version = ARGON2_VERSION_NUMBER;
|
|
instance.memory = memory;
|
|
instance.passes = 1;
|
|
instance.memory_blocks = BENCH_MEM_BLOCKS;
|
|
instance.segment_length = BENCH_MEM_BLOCKS / ARGON2_SYNC_POINTS;
|
|
instance.lane_length = instance.segment_length * ARGON2_SYNC_POINTS;
|
|
instance.lanes = 1;
|
|
instance.threads = 1;
|
|
instance.type = Argon2_i;
|
|
|
|
pos.lane = 0;
|
|
pos.pass = 0;
|
|
pos.slice = 0;
|
|
pos.index = 0;
|
|
|
|
/* warm-up cache: */
|
|
impl->fill_segment(&instance, pos);
|
|
|
|
/* OK, now measure: */
|
|
bench = 0;
|
|
time = clock();
|
|
for (i = 0; i < BENCH_SAMPLES; i++) {
|
|
impl->fill_segment(&instance, pos);
|
|
}
|
|
time = clock() - time;
|
|
bench = (uint64_t)time;
|
|
return bench;
|
|
}
|
|
|
|
static void select_impl(FILE *out, const char *prefix)
|
|
{
|
|
argon2_impl_list impls;
|
|
unsigned int i;
|
|
const argon2_impl *best_impl = NULL;
|
|
uint64_t best_bench = UINT_MAX;
|
|
|
|
log_maybe(out, "%sSelecting best fill_segment implementation...\n", prefix);
|
|
|
|
argon2_get_impl_list(&impls);
|
|
|
|
for (i = 0; i < impls.count; i++) {
|
|
const argon2_impl *impl = &impls.entries[i];
|
|
uint64_t bench;
|
|
|
|
log_maybe(out, "%s%s: Checking availability... ", prefix, impl->name);
|
|
if (impl->check != NULL && !impl->check()) {
|
|
log_maybe(out, "FAILED!\n");
|
|
continue;
|
|
}
|
|
log_maybe(out, "OK!\n");
|
|
|
|
log_maybe(out, "%s%s: Benchmarking...\n", prefix, impl->name);
|
|
bench = benchmark_impl(impl);
|
|
log_maybe(out, "%s%s: Benchmark result: %llu\n", prefix, impl->name,
|
|
(unsigned long long)bench);
|
|
|
|
if (bench < best_bench) {
|
|
best_bench = bench;
|
|
best_impl = impl;
|
|
}
|
|
}
|
|
|
|
if (best_impl != NULL) {
|
|
log_maybe(out,
|
|
"%sBest implementation: '%s' (bench %llu)\n", prefix,
|
|
best_impl->name, (unsigned long long)best_bench);
|
|
|
|
selected_argon_impl = *best_impl;
|
|
} else {
|
|
log_maybe(out,
|
|
"%sNo optimized implementation available, using default!\n",
|
|
prefix);
|
|
}
|
|
}
|
|
|
|
void fill_segment(const argon2_instance_t *instance, argon2_position_t position)
|
|
{
|
|
selected_argon_impl.fill_segment(instance, position);
|
|
}
|
|
|
|
void argon2_select_impl(FILE *out, const char *prefix)
|
|
{
|
|
if (prefix == NULL) {
|
|
prefix = "";
|
|
}
|
|
select_impl(out, prefix);
|
|
}
|