Integrated Argon2 algo chukwa (TRTL) and wrkz (#258)

* 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
2019-07-24 14:03:23 -07:00 · 2019-07-24 14:03:23 -07:00 · dea9b975f8
commit dea9b975f8
parent 78809d44bc
160 changed files with 10341 additions and 151 deletions
--- a/src/3rdparty/argon2/lib/impl-select.c
+++ b/src/3rdparty/argon2/lib/impl-select.c
@ -0,0 +1,120 @@
+#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);
+}