From 1678dc1d6d53fd5bd875671e160a782e2068d6bf Mon Sep 17 00:00:00 2001 From: XMRig Date: Mon, 1 May 2017 03:49:05 +0300 Subject: [PATCH] Implement low power mode (double hash). --- CMakeLists.txt | 17 +- algo/cryptonight/cryptonight.c | 72 ++++-- algo/cryptonight/cryptonight.h | 7 +- .../{cryptonight_p.h => cryptonight_aesni.h} | 47 +++- algo/cryptonight/cryptonight_av1_aesni.c | 14 +- .../cryptonight_av2_aesni_double.c | 111 ++++++++ algo/cryptonight/cryptonight_av2_aesni_stak.c | 77 ------ algo/cryptonight/cryptonight_av3_aesni_bmi2.c | 12 +- algo/cryptonight/cryptonight_av4_softaes.c | 187 +------------- .../cryptonight_av5_aesni_experimental.c | 77 ------ .../cryptonight_av5_softaes_double.c | 111 ++++++++ algo/cryptonight/cryptonight_softaes.h | 237 ++++++++++++++++++ memory.c | 5 +- options.c | 1 + options.h | 5 +- unix/memory_unix.c | 3 +- win/memory_win.c | 3 +- xmrig.c | 90 ++++++- 18 files changed, 686 insertions(+), 390 deletions(-) rename algo/cryptonight/{cryptonight_p.h => cryptonight_aesni.h} (86%) create mode 100644 algo/cryptonight/cryptonight_av2_aesni_double.c delete mode 100644 algo/cryptonight/cryptonight_av2_aesni_stak.c delete mode 100644 algo/cryptonight/cryptonight_av5_aesni_experimental.c create mode 100644 algo/cryptonight/cryptonight_av5_softaes_double.c create mode 100644 algo/cryptonight/cryptonight_softaes.h diff --git a/CMakeLists.txt b/CMakeLists.txt index b23c8bde..96684eb8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,8 @@ project(xmrig C) set(HEADERS compat.h algo/cryptonight/cryptonight.h - algo/cryptonight/cryptonight_p.h + algo/cryptonight/cryptonight_aesni.h + algo/cryptonight/cryptonight_softaes.h elist.h xmrig.h version.h @@ -37,6 +38,10 @@ set(HEADERS_UTILS set(SOURCES xmrig.c algo/cryptonight/cryptonight.c + algo/cryptonight/cryptonight_av1_aesni.c + algo/cryptonight/cryptonight_av2_aesni_double.c + algo/cryptonight/cryptonight_av4_softaes.c + algo/cryptonight/cryptonight_av5_softaes_double.c util.c options.c cpu.c @@ -99,15 +104,7 @@ endif() if (CMAKE_SIZEOF_VOID_P EQUAL 8) add_subdirectory(algo/cryptonight/bmi2) - - set(CRYPTONIGHT64 - algo/cryptonight/cryptonight_av1_aesni.c - algo/cryptonight/cryptonight_av2_aesni_stak.c - algo/cryptonight/cryptonight_av4_softaes.c - algo/cryptonight/cryptonight_av5_aesni_experimental.c - ) - - add_executable(xmrig ${HEADERS} ${HEADERS_CRYPTO} ${SOURCES} ${SOURCES_CRYPTO} ${HEADERS_UTILS} ${SOURCES_UTILS} ${HEADERS_COMPAT} ${SOURCES_COMPAT} ${SOURCES_OS} ${CRYPTONIGHT64}) + add_executable(xmrig ${HEADERS} ${HEADERS_CRYPTO} ${SOURCES} ${SOURCES_CRYPTO} ${HEADERS_UTILS} ${SOURCES_UTILS} ${HEADERS_COMPAT} ${SOURCES_COMPAT} ${SOURCES_OS}) target_link_libraries(xmrig jansson curl cryptonight_av3_aesni_bmi2 ${EXTRA_LIBS}) else() set(CRYPTONIGHT32 diff --git a/algo/cryptonight/cryptonight.c b/algo/cryptonight/cryptonight.c index 01dddb5b..e0bd1d54 100644 --- a/algo/cryptonight/cryptonight.c +++ b/algo/cryptonight/cryptonight.c @@ -38,7 +38,12 @@ #include "options.h" -const static char test_input[76] = { +const static char test_input[152] = { + 0x03, 0x05, 0xA0, 0xDB, 0xD6, 0xBF, 0x05, 0xCF, 0x16, 0xE5, 0x03, 0xF3, 0xA6, 0x6F, 0x78, 0x00, + 0x7C, 0xBF, 0x34, 0x14, 0x43, 0x32, 0xEC, 0xBF, 0xC2, 0x2E, 0xD9, 0x5C, 0x87, 0x00, 0x38, 0x3B, + 0x30, 0x9A, 0xCE, 0x19, 0x23, 0xA0, 0x96, 0x4B, 0x00, 0x00, 0x00, 0x08, 0xBA, 0x93, 0x9A, 0x62, + 0x72, 0x4C, 0x0D, 0x75, 0x81, 0xFC, 0xE5, 0x76, 0x1E, 0x9D, 0x8A, 0x0E, 0x6A, 0x1C, 0x3F, 0x92, + 0x4F, 0xDD, 0x84, 0x93, 0xD1, 0x11, 0x56, 0x49, 0xC0, 0x5E, 0xB6, 0x01, 0x03, 0x05, 0xA0, 0xDB, 0xD6, 0xBF, 0x05, 0xCF, 0x16, 0xE5, 0x03, 0xF3, 0xA6, 0x6F, 0x78, 0x00, 0x7C, 0xBF, 0x34, 0x14, 0x43, 0x32, 0xEC, 0xBF, 0xC2, 0x2E, 0xD9, 0x5C, 0x87, 0x00, 0x38, 0x3B, 0x30, 0x9A, 0xCE, 0x19, 0x23, 0xA0, 0x96, 0x4B, 0x00, 0x00, 0x00, 0x08, 0xBA, 0x93, 0x9A, 0x62, @@ -47,36 +52,38 @@ const static char test_input[76] = { }; -const static char test_output[32] = { +const static char test_output[64] = { + 0x1A, 0x3F, 0xFB, 0xEE, 0x90, 0x9B, 0x42, 0x0D, 0x91, 0xF7, 0xBE, 0x6E, 0x5F, 0xB5, 0x6D, 0xB7, + 0x1B, 0x31, 0x10, 0xD8, 0x86, 0x01, 0x1E, 0x87, 0x7E, 0xE5, 0x78, 0x6A, 0xFD, 0x08, 0x01, 0x00, 0x1A, 0x3F, 0xFB, 0xEE, 0x90, 0x9B, 0x42, 0x0D, 0x91, 0xF7, 0xBE, 0x6E, 0x5F, 0xB5, 0x6D, 0xB7, 0x1B, 0x31, 0x10, 0xD8, 0x86, 0x01, 0x1E, 0x87, 0x7E, 0xE5, 0x78, 0x6A, 0xFD, 0x08, 0x01, 0x00 }; void cryptonight_av1_aesni(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx); +void cryptonight_av2_aesni_double(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx); void cryptonight_av4_softaes(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx); +void cryptonight_av5_softaes_double(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx); #if defined(__x86_64__) - void cryptonight_av2_aesni_stak(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx); void cryptonight_av3_aesni_bmi2(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx); - void cryptonight_av5_aesni_experimental(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx); #endif void (*cryptonight_hash_ctx)(const void* input, size_t size, void* output, struct cryptonight_ctx* ctx) = NULL; static bool self_test() { - char output[32]; + char output[64]; struct cryptonight_ctx *ctx = (struct cryptonight_ctx*) _mm_malloc(sizeof(struct cryptonight_ctx), 16); - ctx->memory = (uint8_t *) _mm_malloc(MEMORY, 16); + ctx->memory = (uint8_t *) _mm_malloc(MEMORY * 2, 16); - cryptonight_hash_ctx(test_input, sizeof(test_input), output, ctx); + cryptonight_hash_ctx(test_input, 76, output, ctx); _mm_free(ctx->memory); _mm_free(ctx); - return memcmp(output, test_output, 32) == 0; + return memcmp(output, test_output, (opt_double_hash ? 64 : 32)) == 0; } @@ -87,23 +94,25 @@ bool cryptonight_init(int variant) cryptonight_hash_ctx = cryptonight_av1_aesni; break; -# if defined(__x86_64__) - case XMR_AV2_STAK: - cryptonight_hash_ctx = cryptonight_av2_aesni_stak; + case XMR_AV2_AESNI_DOUBLE: + opt_double_hash = true; + cryptonight_hash_ctx = cryptonight_av2_aesni_double; break; +# if defined(__x86_64__) case XMR_AV3_AESNI_BMI2: cryptonight_hash_ctx = cryptonight_av3_aesni_bmi2; break; - - case XMR_AV5_EXPERIMENTAL: - cryptonight_hash_ctx = cryptonight_av5_aesni_experimental; - break; # endif case XMR_AV4_SOFT_AES: - cryptonight_hash_ctx = cryptonight_av4_softaes; - break; + cryptonight_hash_ctx = cryptonight_av4_softaes; + break; + + case XMR_AV5_SOFT_AES_DOUBLE: + opt_double_hash = true; + cryptonight_hash_ctx = cryptonight_av5_softaes_double; + break; default: break; @@ -153,4 +162,33 @@ int scanhash_cryptonight(int thr_id, uint32_t *hash, uint32_t *restrict blob, si return 0; } + + +int scanhash_cryptonight_double(int thr_id, uint32_t *hash, uint8_t *restrict blob, size_t blob_size, uint32_t target, uint32_t max_nonce, unsigned long *restrict hashes_done, struct cryptonight_ctx *restrict ctx) { + int rc = 0; + uint32_t *nonceptr0 = (uint32_t*) (((char*) blob) + 39); + uint32_t *nonceptr1 = (uint32_t*) (((char*) blob) + 39 + blob_size); + + do { + cryptonight_hash_ctx(blob, blob_size, hash, ctx); + (*hashes_done) += 2; + + if (unlikely(hash[7] < target)) { + return rc |= 1; + } + + if (unlikely(hash[15] < target)) { + return rc |= 2; + } + + if (rc) { + break; + } + + (*nonceptr0)++; + (*nonceptr1)++; + } while (likely(((*nonceptr0) < max_nonce && !work_restart[thr_id].restart))); + + return rc; +} #endif diff --git a/algo/cryptonight/cryptonight.h b/algo/cryptonight/cryptonight.h index c238da7a..1770ac82 100644 --- a/algo/cryptonight/cryptonight.h +++ b/algo/cryptonight/cryptonight.h @@ -30,10 +30,10 @@ #define MEMORY 2097152 /* 2 MiB */ - struct cryptonight_ctx { - uint8_t state[200] __attribute__((aligned(16))); - uint8_t* memory __attribute__((aligned(16))); + uint8_t state0[200] __attribute__((aligned(16))); + uint8_t state1[200] __attribute__((aligned(16))); + uint8_t* memory __attribute__((aligned(16))); }; @@ -41,5 +41,6 @@ extern void (* const extra_hashes[4])(const void *, size_t, char *); bool cryptonight_init(int variant); int scanhash_cryptonight(int thr_id, uint32_t *hash, uint32_t *restrict blob, size_t blob_size, uint32_t target, uint32_t max_nonce, unsigned long *restrict hashes_done, struct cryptonight_ctx *restrict ctx); +int scanhash_cryptonight_double(int thr_id, uint32_t *hash, uint8_t *restrict blob, size_t blob_size, uint32_t target, uint32_t max_nonce, unsigned long *restrict hashes_done, struct cryptonight_ctx *restrict ctx); #endif /* __CRYPTONIGHT_H__ */ diff --git a/algo/cryptonight/cryptonight_p.h b/algo/cryptonight/cryptonight_aesni.h similarity index 86% rename from algo/cryptonight/cryptonight_p.h rename to algo/cryptonight/cryptonight_aesni.h index b7f18765..30ad690a 100644 --- a/algo/cryptonight/cryptonight_p.h +++ b/algo/cryptonight/cryptonight_aesni.h @@ -22,8 +22,8 @@ * along with this program. If not, see . */ -#ifndef __CRYPTONIGHT_P_H__ -#define __CRYPTONIGHT_P_H__ +#ifndef __CRYPTONIGHT_AESNI_H__ +#define __CRYPTONIGHT_AESNI_H__ #include @@ -149,12 +149,10 @@ inline void cn_explode_scratchpad(const __m128i* input, __m128i* output) _mm_store_si128(output + i + 1, xin1); _mm_store_si128(output + i + 2, xin2); _mm_store_si128(output + i + 3, xin3); - _mm_prefetch((const char*)output + i + 0, _MM_HINT_T2); _mm_store_si128(output + i + 4, xin4); _mm_store_si128(output + i + 5, xin5); _mm_store_si128(output + i + 6, xin6); _mm_store_si128(output + i + 7, xin7); - _mm_prefetch((const char*)output + i + 4, _MM_HINT_T2); } } @@ -178,12 +176,10 @@ inline void cn_implode_scratchpad(const __m128i* input, __m128i* output) for (size_t i = 0; __builtin_expect(i < MEMORY / sizeof(__m128i), 1); i += 8) { - _mm_prefetch((const char*)input + i + 0, _MM_HINT_NTA); xout0 = _mm_xor_si128(_mm_load_si128(input + i + 0), xout0); xout1 = _mm_xor_si128(_mm_load_si128(input + i + 1), xout1); xout2 = _mm_xor_si128(_mm_load_si128(input + i + 2), xout2); xout3 = _mm_xor_si128(_mm_load_si128(input + i + 3), xout3); - _mm_prefetch((const char*)input + i + 4, _MM_HINT_NTA); xout4 = _mm_xor_si128(_mm_load_si128(input + i + 4), xout4); xout5 = _mm_xor_si128(_mm_load_si128(input + i + 5), xout5); xout6 = _mm_xor_si128(_mm_load_si128(input + i + 6), xout6); @@ -212,12 +208,49 @@ inline void cn_implode_scratchpad(const __m128i* input, __m128i* output) } +#if defined(__x86_64__) +# define EXTRACT64(X) _mm_cvtsi128_si64(X) + inline uint64_t _umul128(uint64_t a, uint64_t b, uint64_t* hi) { unsigned __int128 r = (unsigned __int128) a * (unsigned __int128) b; *hi = r >> 64; return (uint64_t) r; } +#elif defined(__i386__) +# define HI32(X) \ + _mm_srli_si128((X), 4) -#endif /* __CRYPTONIGHT_P_H__ */ +# define EXTRACT64(X) \ + ((uint64_t)(uint32_t)_mm_cvtsi128_si32(X) | \ + ((uint64_t)(uint32_t)_mm_cvtsi128_si32(HI32(X)) << 32)) + +inline uint64_t _umul128(uint64_t multiplier, uint64_t multiplicand, uint64_t *product_hi) { + // multiplier = ab = a * 2^32 + b + // multiplicand = cd = c * 2^32 + d + // ab * cd = a * c * 2^64 + (a * d + b * c) * 2^32 + b * d + uint64_t a = multiplier >> 32; + uint64_t b = multiplier & 0xFFFFFFFF; + uint64_t c = multiplicand >> 32; + uint64_t d = multiplicand & 0xFFFFFFFF; + + //uint64_t ac = a * c; + uint64_t ad = a * d; + //uint64_t bc = b * c; + uint64_t bd = b * d; + + uint64_t adbc = ad + (b * c); + uint64_t adbc_carry = adbc < ad ? 1 : 0; + + // multiplier * multiplicand = product_hi * 2^64 + product_lo + uint64_t product_lo = bd + (adbc << 32); + uint64_t product_lo_carry = product_lo < bd ? 1 : 0; + *product_hi = (a * c) + (adbc >> 32) + (adbc_carry << 32) + product_lo_carry; + + return product_lo; +} +#endif + + +#endif /* __CRYPTONIGHT_AESNI_H__ */ diff --git a/algo/cryptonight/cryptonight_av1_aesni.c b/algo/cryptonight/cryptonight_av1_aesni.c index 4b1a766c..3f30544e 100644 --- a/algo/cryptonight/cryptonight_av1_aesni.c +++ b/algo/cryptonight/cryptonight_av1_aesni.c @@ -26,18 +26,18 @@ #include #include "cryptonight.h" -#include "cryptonight_p.h" +#include "cryptonight_aesni.h" #include "crypto/c_keccak.h" void cryptonight_av1_aesni(const void *restrict input, size_t size, void *restrict output, struct cryptonight_ctx *restrict ctx) { - keccak((const uint8_t *) input, size, ctx->state, 200); + keccak((const uint8_t *) input, size, ctx->state0, 200); - cn_explode_scratchpad((__m128i*) ctx->state, (__m128i*) ctx->memory); + cn_explode_scratchpad((__m128i*) ctx->state0, (__m128i*) ctx->memory); const uint8_t* l0 = ctx->memory; - uint64_t* h0 = (uint64_t*) ctx->state; + uint64_t* h0 = (uint64_t*) ctx->state0; uint64_t al0 = h0[0] ^ h0[4]; uint64_t ah0 = h0[1] ^ h0[5]; @@ -51,7 +51,7 @@ void cryptonight_av1_aesni(const void *restrict input, size_t size, void *restri cx = _mm_aesenc_si128(cx, _mm_set_epi64x(ah0, al0)); _mm_store_si128((__m128i *) &l0[idx0 & 0x1FFFF0], _mm_xor_si128(bx0, cx)); - idx0 = _mm_cvtsi128_si64(cx); + idx0 = EXTRACT64(cx); bx0 = cx; uint64_t hi, lo, cl, ch; @@ -70,8 +70,8 @@ void cryptonight_av1_aesni(const void *restrict input, size_t size, void *restri idx0 = al0; } - cn_implode_scratchpad((__m128i*) ctx->memory, (__m128i*) ctx->state); + cn_implode_scratchpad((__m128i*) ctx->memory, (__m128i*) ctx->state0); keccakf(h0, 24); - extra_hashes[ctx->state[0] & 3](ctx->state, 200, output); + extra_hashes[ctx->state0[0] & 3](ctx->state0, 200, output); } diff --git a/algo/cryptonight/cryptonight_av2_aesni_double.c b/algo/cryptonight/cryptonight_av2_aesni_double.c new file mode 100644 index 00000000..779b9bc3 --- /dev/null +++ b/algo/cryptonight/cryptonight_av2_aesni_double.c @@ -0,0 +1,111 @@ +/* XMRig + * Copyright 2010 Jeff Garzik + * Copyright 2012-2014 pooler + * Copyright 2014 Lucas Jones + * Copyright 2014-2016 Wolf9466 + * Copyright 2016 Jay D Dee + * Copyright 2017 fireice-uk + * Copyright 2016-2017 XMRig + * + * + * 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, either version 3 of the License, or + * (at your option) any later version. + * + * 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, see . + */ + +#include +#include + +#include "cryptonight.h" +#include "cryptonight_aesni.h" +#include "crypto/c_keccak.h" + + +void cryptonight_av2_aesni_double(const void *restrict input, size_t size, void *restrict output, struct cryptonight_ctx *restrict ctx) +{ + keccak((const uint8_t *) input, size, ctx->state0, 200); + keccak((const uint8_t *) input + size, size, ctx->state1, 200); + + const uint8_t* l0 = ctx->memory; + const uint8_t* l1 = ctx->memory + MEMORY; + uint64_t* h0 = (uint64_t*) ctx->state0; + uint64_t* h1 = (uint64_t*) ctx->state1; + + cn_explode_scratchpad((__m128i*) h0, (__m128i*) l0); + cn_explode_scratchpad((__m128i*) h1, (__m128i*) l1); + + uint64_t al0 = h0[0] ^ h0[4]; + uint64_t al1 = h1[0] ^ h1[4]; + uint64_t ah0 = h0[1] ^ h0[5]; + uint64_t ah1 = h1[1] ^ h1[5]; + + __m128i bx0 = _mm_set_epi64x(h0[3] ^ h0[7], h0[2] ^ h0[6]); + __m128i bx1 = _mm_set_epi64x(h1[3] ^ h1[7], h1[2] ^ h1[6]); + + uint64_t idx0 = h0[0] ^ h0[4]; + uint64_t idx1 = h1[0] ^ h1[4]; + + for (size_t i = 0; __builtin_expect(i < 0x80000, 1); i++) { + __m128i cx0 = _mm_load_si128((__m128i *) &l0[idx0 & 0x1FFFF0]); + __m128i cx1 = _mm_load_si128((__m128i *) &l1[idx1 & 0x1FFFF0]); + + cx0 = _mm_aesenc_si128(cx0, _mm_set_epi64x(ah0, al0)); + cx1 = _mm_aesenc_si128(cx1, _mm_set_epi64x(ah1, al1)); + + _mm_store_si128((__m128i *) &l0[idx0 & 0x1FFFF0], _mm_xor_si128(bx0, cx0)); + _mm_store_si128((__m128i *) &l1[idx1 & 0x1FFFF0], _mm_xor_si128(bx1, cx1)); + + idx0 = EXTRACT64(cx0); + idx1 = EXTRACT64(cx1); + + bx0 = cx0; + bx1 = cx1; + + uint64_t hi, lo, cl, ch; + cl = ((uint64_t*) &l0[idx0 & 0x1FFFF0])[0]; + ch = ((uint64_t*) &l0[idx0 & 0x1FFFF0])[1]; + lo = _umul128(idx0, cl, &hi); + + al0 += hi; + ah0 += lo; + + ((uint64_t*) &l0[idx0 & 0x1FFFF0])[0] = al0; + ((uint64_t*) &l0[idx0 & 0x1FFFF0])[1] = ah0; + + ah0 ^= ch; + al0 ^= cl; + idx0 = al0; + + cl = ((uint64_t*) &l1[idx1 & 0x1FFFF0])[0]; + ch = ((uint64_t*) &l1[idx1 & 0x1FFFF0])[1]; + lo = _umul128(idx1, cl, &hi); + + al1 += hi; + ah1 += lo; + + ((uint64_t*) &l1[idx1 & 0x1FFFF0])[0] = al1; + ((uint64_t*) &l1[idx1 & 0x1FFFF0])[1] = ah1; + + ah1 ^= ch; + al1 ^= cl; + idx1 = al1; + } + + cn_implode_scratchpad((__m128i*) l0, (__m128i*) h0); + cn_implode_scratchpad((__m128i*) l1, (__m128i*) h1); + + keccakf(h0, 24); + keccakf(h1, 24); + + extra_hashes[ctx->state0[0] & 3](ctx->state0, 200, output); + extra_hashes[ctx->state1[0] & 3](ctx->state1, 200, (char*) output + 32); +} diff --git a/algo/cryptonight/cryptonight_av2_aesni_stak.c b/algo/cryptonight/cryptonight_av2_aesni_stak.c deleted file mode 100644 index df96c651..00000000 --- a/algo/cryptonight/cryptonight_av2_aesni_stak.c +++ /dev/null @@ -1,77 +0,0 @@ -/* XMRig - * Copyright 2010 Jeff Garzik - * Copyright 2012-2014 pooler - * Copyright 2014 Lucas Jones - * Copyright 2014-2016 Wolf9466 - * Copyright 2016 Jay D Dee - * Copyright 2017 fireice-uk - * Copyright 2016-2017 XMRig - * - * - * 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, either version 3 of the License, or - * (at your option) any later version. - * - * 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, see . - */ - -#include -#include - -#include "cryptonight.h" -#include "cryptonight_p.h" -#include "crypto/c_keccak.h" - - -void cryptonight_av2_aesni_stak(const void *restrict input, size_t size, void *restrict output, struct cryptonight_ctx *restrict ctx) -{ - keccak((const uint8_t *) input, size, ctx->state, 200); - - cn_explode_scratchpad((__m128i*) ctx->state, (__m128i*) ctx->memory); - - const uint8_t* l0 = ctx->memory; - uint64_t* h0 = (uint64_t*) ctx->state; - - uint64_t al0 = h0[0] ^ h0[4]; - uint64_t ah0 = h0[1] ^ h0[5]; - __m128i bx0 = _mm_set_epi64x(h0[3] ^ h0[7], h0[2] ^ h0[6]); - - uint64_t idx0 = h0[0] ^ h0[4]; - - for (size_t i = 0; __builtin_expect(i < 0x80000, 1); i++) { - __m128i cx; - cx = _mm_load_si128((__m128i *)&l0[idx0 & 0x1FFFF0]); - cx = _mm_aesenc_si128(cx, _mm_set_epi64x(ah0, al0)); - - _mm_store_si128((__m128i *)&l0[idx0 & 0x1FFFF0], _mm_xor_si128(bx0, cx)); - idx0 = _mm_cvtsi128_si64(cx); - bx0 = cx; - - uint64_t hi, lo, cl, ch; - cl = ((uint64_t*)&l0[idx0 & 0x1FFFF0])[0]; - ch = ((uint64_t*)&l0[idx0 & 0x1FFFF0])[1]; - lo = _umul128(idx0, cl, &hi); - - al0 += hi; - ah0 += lo; - - ((uint64_t*)&l0[idx0 & 0x1FFFF0])[0] = al0; - ((uint64_t*)&l0[idx0 & 0x1FFFF0])[1] = ah0; - - ah0 ^= ch; - al0 ^= cl; - idx0 = al0; - } - - cn_implode_scratchpad((__m128i*) ctx->memory, (__m128i*) ctx->state); - - keccakf(h0, 24); - extra_hashes[ctx->state[0] & 3](ctx->state, 200, output); -} diff --git a/algo/cryptonight/cryptonight_av3_aesni_bmi2.c b/algo/cryptonight/cryptonight_av3_aesni_bmi2.c index 6ebfb7ef..18582fce 100644 --- a/algo/cryptonight/cryptonight_av3_aesni_bmi2.c +++ b/algo/cryptonight/cryptonight_av3_aesni_bmi2.c @@ -26,18 +26,18 @@ #include #include "cryptonight.h" -#include "cryptonight_p.h" +#include "cryptonight_aesni.h" #include "crypto/c_keccak.h" void cryptonight_av3_aesni_bmi2(const void *restrict input, size_t size, void *restrict output, struct cryptonight_ctx *restrict ctx) { - keccak((const uint8_t *) input, size, ctx->state, 200); + keccak((const uint8_t *) input, size, ctx->state0, 200); - cn_explode_scratchpad((__m128i*) ctx->state, (__m128i*) ctx->memory); + cn_explode_scratchpad((__m128i*) ctx->state0, (__m128i*) ctx->memory); const uint8_t* l0 = ctx->memory; - uint64_t* h0 = (uint64_t*) ctx->state; + uint64_t* h0 = (uint64_t*) ctx->state0; uint64_t al0 = h0[0] ^ h0[4]; uint64_t ah0 = h0[1] ^ h0[5]; @@ -70,8 +70,8 @@ void cryptonight_av3_aesni_bmi2(const void *restrict input, size_t size, void *r idx0 = al0; } - cn_implode_scratchpad((__m128i*) ctx->memory, (__m128i*) ctx->state); + cn_implode_scratchpad((__m128i*) ctx->memory, (__m128i*) ctx->state0); keccakf(h0, 24); - extra_hashes[ctx->state[0] & 3](ctx->state, 200, output); + extra_hashes[ctx->state0[0] & 3](ctx->state0, 200, output); } diff --git a/algo/cryptonight/cryptonight_av4_softaes.c b/algo/cryptonight/cryptonight_av4_softaes.c index b7a17af7..cd0fc6f2 100644 --- a/algo/cryptonight/cryptonight_av4_softaes.c +++ b/algo/cryptonight/cryptonight_av4_softaes.c @@ -26,191 +26,18 @@ #include #include "cryptonight.h" +#include "cryptonight_softaes.h" #include "crypto/c_keccak.h" -__m128i soft_aesenc(__m128i in, __m128i key); -__m128i soft_aeskeygenassist(__m128i key, uint8_t rcon); - -#ifdef __GNUC__ -static inline uint64_t _umul128(uint64_t a, uint64_t b, uint64_t* hi) -{ - unsigned __int128 r = (unsigned __int128)a * (unsigned __int128)b; - *hi = r >> 64; - return (uint64_t)r; -} -#endif - - -// This will shift and xor tmp1 into itself as 4 32-bit vals such as -// sl_xor(a1 a2 a3 a4) = a1 (a2^a1) (a3^a2^a1) (a4^a3^a2^a1) -static inline __m128i sl_xor(__m128i tmp1) -{ - __m128i tmp4; - tmp4 = _mm_slli_si128(tmp1, 0x04); - tmp1 = _mm_xor_si128(tmp1, tmp4); - tmp4 = _mm_slli_si128(tmp4, 0x04); - tmp1 = _mm_xor_si128(tmp1, tmp4); - tmp4 = _mm_slli_si128(tmp4, 0x04); - tmp1 = _mm_xor_si128(tmp1, tmp4); - return tmp1; -} - - -static inline void aes_genkey_sub(__m128i* xout0, __m128i* xout2, uint8_t rcon) -{ - __m128i xout1 = soft_aeskeygenassist(*xout2, rcon); - xout1 = _mm_shuffle_epi32(xout1, 0xFF); // see PSHUFD, set all elems to 4th elem - *xout0 = sl_xor(*xout0); - *xout0 = _mm_xor_si128(*xout0, xout1); - xout1 = soft_aeskeygenassist(*xout0, 0x00); - xout1 = _mm_shuffle_epi32(xout1, 0xAA); // see PSHUFD, set all elems to 3rd elem - *xout2 = sl_xor(*xout2); - *xout2 = _mm_xor_si128(*xout2, xout1); -} - - -static inline void aes_genkey(const __m128i* memory, __m128i* k0, __m128i* k1, __m128i* k2, __m128i* k3, __m128i* k4, __m128i* k5, __m128i* k6, __m128i* k7, __m128i* k8, __m128i* k9) -{ - __m128i xout0 = _mm_load_si128(memory); - __m128i xout2 = _mm_load_si128(memory + 1); - *k0 = xout0; - *k1 = xout2; - - aes_genkey_sub(&xout0, &xout2, 0x1); - *k2 = xout0; - *k3 = xout2; - - aes_genkey_sub(&xout0, &xout2, 0x2); - *k4 = xout0; - *k5 = xout2; - - aes_genkey_sub(&xout0, &xout2, 0x4); - *k6 = xout0; - *k7 = xout2; - - aes_genkey_sub(&xout0, &xout2, 0x8); - *k8 = xout0; - *k9 = xout2; -} - - -static inline void aes_round(__m128i key, __m128i* x0, __m128i* x1, __m128i* x2, __m128i* x3, __m128i* x4, __m128i* x5, __m128i* x6, __m128i* x7) -{ - *x0 = soft_aesenc(*x0, key); - *x1 = soft_aesenc(*x1, key); - *x2 = soft_aesenc(*x2, key); - *x3 = soft_aesenc(*x3, key); - *x4 = soft_aesenc(*x4, key); - *x5 = soft_aesenc(*x5, key); - *x6 = soft_aesenc(*x6, key); - *x7 = soft_aesenc(*x7, key); -} - - -static inline void cn_explode_scratchpad(const __m128i* input, __m128i* output) -{ - // This is more than we have registers, compiler will assign 2 keys on the stack - __m128i xin0, xin1, xin2, xin3, xin4, xin5, xin6, xin7; - __m128i k0, k1, k2, k3, k4, k5, k6, k7, k8, k9; - - aes_genkey(input, &k0, &k1, &k2, &k3, &k4, &k5, &k6, &k7, &k8, &k9); - - xin0 = _mm_load_si128(input + 4); - xin1 = _mm_load_si128(input + 5); - xin2 = _mm_load_si128(input + 6); - xin3 = _mm_load_si128(input + 7); - xin4 = _mm_load_si128(input + 8); - xin5 = _mm_load_si128(input + 9); - xin6 = _mm_load_si128(input + 10); - xin7 = _mm_load_si128(input + 11); - - for (size_t i = 0; i < MEMORY / sizeof(__m128i); i += 8) { - aes_round(k0, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - aes_round(k1, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - aes_round(k2, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - aes_round(k3, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - aes_round(k4, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - aes_round(k5, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - aes_round(k6, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - aes_round(k7, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - aes_round(k8, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - aes_round(k9, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); - - _mm_store_si128(output + i + 0, xin0); - _mm_store_si128(output + i + 1, xin1); - _mm_store_si128(output + i + 2, xin2); - _mm_store_si128(output + i + 3, xin3); - _mm_prefetch((const char*)output + i + 0, _MM_HINT_T2); - _mm_store_si128(output + i + 4, xin4); - _mm_store_si128(output + i + 5, xin5); - _mm_store_si128(output + i + 6, xin6); - _mm_store_si128(output + i + 7, xin7); - _mm_prefetch((const char*)output + i + 4, _MM_HINT_T2); - } -} - - -static inline void cn_implode_scratchpad(const __m128i* input, __m128i* output) -{ - // This is more than we have registers, compiler will assign 2 keys on the stack - __m128i xout0, xout1, xout2, xout3, xout4, xout5, xout6, xout7; - __m128i k0, k1, k2, k3, k4, k5, k6, k7, k8, k9; - - aes_genkey(output + 2, &k0, &k1, &k2, &k3, &k4, &k5, &k6, &k7, &k8, &k9); - - xout0 = _mm_load_si128(output + 4); - xout1 = _mm_load_si128(output + 5); - xout2 = _mm_load_si128(output + 6); - xout3 = _mm_load_si128(output + 7); - xout4 = _mm_load_si128(output + 8); - xout5 = _mm_load_si128(output + 9); - xout6 = _mm_load_si128(output + 10); - xout7 = _mm_load_si128(output + 11); - - for (size_t i = 0; i < MEMORY / sizeof(__m128i); i += 8) - { - _mm_prefetch((const char*)input + i + 0, _MM_HINT_NTA); - xout0 = _mm_xor_si128(_mm_load_si128(input + i + 0), xout0); - xout1 = _mm_xor_si128(_mm_load_si128(input + i + 1), xout1); - xout2 = _mm_xor_si128(_mm_load_si128(input + i + 2), xout2); - xout3 = _mm_xor_si128(_mm_load_si128(input + i + 3), xout3); - _mm_prefetch((const char*)input + i + 4, _MM_HINT_NTA); - xout4 = _mm_xor_si128(_mm_load_si128(input + i + 4), xout4); - xout5 = _mm_xor_si128(_mm_load_si128(input + i + 5), xout5); - xout6 = _mm_xor_si128(_mm_load_si128(input + i + 6), xout6); - xout7 = _mm_xor_si128(_mm_load_si128(input + i + 7), xout7); - - aes_round(k0, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - aes_round(k1, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - aes_round(k2, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - aes_round(k3, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - aes_round(k4, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - aes_round(k5, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - aes_round(k6, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - aes_round(k7, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - aes_round(k8, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - aes_round(k9, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); - } - - _mm_store_si128(output + 4, xout0); - _mm_store_si128(output + 5, xout1); - _mm_store_si128(output + 6, xout2); - _mm_store_si128(output + 7, xout3); - _mm_store_si128(output + 8, xout4); - _mm_store_si128(output + 9, xout5); - _mm_store_si128(output + 10, xout6); - _mm_store_si128(output + 11, xout7); -} - void cryptonight_av4_softaes(const void *restrict input, size_t size, void *restrict output, struct cryptonight_ctx *restrict ctx) { - keccak((const uint8_t *) input, size, ctx->state, 200); + keccak((const uint8_t *) input, size, ctx->state0, 200); - cn_explode_scratchpad((__m128i*) ctx->state, (__m128i*) ctx->memory); + cn_explode_scratchpad((__m128i*) ctx->state0, (__m128i*) ctx->memory); const uint8_t* l0 = ctx->memory; - uint64_t* h0 = (uint64_t*) ctx->state; + uint64_t* h0 = (uint64_t*) ctx->state0; uint64_t al0 = h0[0] ^ h0[4]; uint64_t ah0 = h0[1] ^ h0[5]; @@ -224,7 +51,7 @@ void cryptonight_av4_softaes(const void *restrict input, size_t size, void *rest cx = soft_aesenc(cx, _mm_set_epi64x(ah0, al0)); _mm_store_si128((__m128i *)&l0[idx0 & 0x1FFFF0], _mm_xor_si128(bx0, cx)); - idx0 = _mm_cvtsi128_si64(cx); + idx0 = EXTRACT64(cx); bx0 = cx; uint64_t hi, lo, cl, ch; @@ -243,8 +70,8 @@ void cryptonight_av4_softaes(const void *restrict input, size_t size, void *rest idx0 = al0; } - cn_implode_scratchpad((__m128i*) ctx->memory, (__m128i*) ctx->state); + cn_implode_scratchpad((__m128i*) ctx->memory, (__m128i*) ctx->state0); keccakf(h0, 24); - extra_hashes[ctx->state[0] & 3](ctx->state, 200, output); + extra_hashes[ctx->state0[0] & 3](ctx->state0, 200, output); } diff --git a/algo/cryptonight/cryptonight_av5_aesni_experimental.c b/algo/cryptonight/cryptonight_av5_aesni_experimental.c deleted file mode 100644 index 21e82338..00000000 --- a/algo/cryptonight/cryptonight_av5_aesni_experimental.c +++ /dev/null @@ -1,77 +0,0 @@ -/* XMRig - * Copyright 2010 Jeff Garzik - * Copyright 2012-2014 pooler - * Copyright 2014 Lucas Jones - * Copyright 2014-2016 Wolf9466 - * Copyright 2016 Jay D Dee - * Copyright 2017 fireice-uk - * Copyright 2016-2017 XMRig - * - * - * 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, either version 3 of the License, or - * (at your option) any later version. - * - * 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, see . - */ - -#include -#include - -#include "cryptonight.h" -#include "cryptonight_p.h" -#include "crypto/c_keccak.h" - - -void cryptonight_av5_aesni_experimental(const void *restrict input, size_t size, void *restrict output, struct cryptonight_ctx *restrict ctx) -{ - const uint8_t* memory = ctx->memory; - - keccak((const uint8_t *) input, size, ctx->state, 200); - cn_explode_scratchpad((__m128i*) ctx->state, (__m128i*) memory); - - uint64_t* state = (uint64_t*) ctx->state; - - uint64_t a[2] __attribute((aligned(16))) = { state[0] ^ state[4], state[1] ^ state[5] }; - uint64_t c __attribute((aligned(16))); - uint64_t d[2] __attribute((aligned(16))); - - __m128i a_x = _mm_load_si128((__m128i *) &memory[a[0] & 0x1FFFF0]); - __m128i b_x = _mm_set_epi64x(state[3] ^ state[7], state[2] ^ state[6]); - - for (size_t i = 0; __builtin_expect(i < 0x80000, 1); i++) { - __m128i c_x = _mm_aesenc_si128(a_x, _mm_load_si128((__m128i *) a)); - c = _mm_cvtsi128_si64(c_x); - - uint64_t *restrict d_ptr = (uint64_t *) &memory[c & 0x1FFFF0]; - _mm_store_si128((__m128i *) &memory[a[0] & 0x1FFFF0], _mm_xor_si128(b_x, c_x)); - b_x = c_x; - - d[0] = d_ptr[0]; - d[1] = d_ptr[1]; - - { - unsigned __int128 res = (unsigned __int128) c * d[0]; - - d_ptr[0] = a[0] += res >> 64; - d_ptr[1] = a[1] += (uint64_t) res; - } - - a[0] ^= d[0]; - a[1] ^= d[1]; - - a_x = _mm_load_si128((__m128i *) &memory[a[0] & 0x1FFFF0]); - } - - cn_implode_scratchpad((__m128i*) memory, (__m128i*) state); - - keccakf(state, 24); - extra_hashes[ctx->state[0] & 3](ctx->state, 200, output); -} diff --git a/algo/cryptonight/cryptonight_av5_softaes_double.c b/algo/cryptonight/cryptonight_av5_softaes_double.c new file mode 100644 index 00000000..113e228c --- /dev/null +++ b/algo/cryptonight/cryptonight_av5_softaes_double.c @@ -0,0 +1,111 @@ +/* XMRig + * Copyright 2010 Jeff Garzik + * Copyright 2012-2014 pooler + * Copyright 2014 Lucas Jones + * Copyright 2014-2016 Wolf9466 + * Copyright 2016 Jay D Dee + * Copyright 2017 fireice-uk + * Copyright 2016-2017 XMRig + * + * + * 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, either version 3 of the License, or + * (at your option) any later version. + * + * 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, see . + */ + +#include +#include + +#include "cryptonight.h" +#include "cryptonight_softaes.h" +#include "crypto/c_keccak.h" + + +void cryptonight_av5_softaes_double(const void *restrict input, size_t size, void *restrict output, struct cryptonight_ctx *restrict ctx) +{ + keccak((const uint8_t *) input, size, ctx->state0, 200); + keccak((const uint8_t *) input + size, size, ctx->state1, 200); + + const uint8_t* l0 = ctx->memory; + const uint8_t* l1 = ctx->memory + MEMORY; + uint64_t* h0 = (uint64_t*) ctx->state0; + uint64_t* h1 = (uint64_t*) ctx->state1; + + cn_explode_scratchpad((__m128i*) h0, (__m128i*) l0); + cn_explode_scratchpad((__m128i*) h1, (__m128i*) l1); + + uint64_t al0 = h0[0] ^ h0[4]; + uint64_t al1 = h1[0] ^ h1[4]; + uint64_t ah0 = h0[1] ^ h0[5]; + uint64_t ah1 = h1[1] ^ h1[5]; + + __m128i bx0 = _mm_set_epi64x(h0[3] ^ h0[7], h0[2] ^ h0[6]); + __m128i bx1 = _mm_set_epi64x(h1[3] ^ h1[7], h1[2] ^ h1[6]); + + uint64_t idx0 = h0[0] ^ h0[4]; + uint64_t idx1 = h1[0] ^ h1[4]; + + for (size_t i = 0; __builtin_expect(i < 0x80000, 1); i++) { + __m128i cx0 = _mm_load_si128((__m128i *) &l0[idx0 & 0x1FFFF0]); + __m128i cx1 = _mm_load_si128((__m128i *) &l1[idx1 & 0x1FFFF0]); + + cx0 = soft_aesenc(cx0, _mm_set_epi64x(ah0, al0)); + cx1 = soft_aesenc(cx1, _mm_set_epi64x(ah1, al1)); + + _mm_store_si128((__m128i *) &l0[idx0 & 0x1FFFF0], _mm_xor_si128(bx0, cx0)); + _mm_store_si128((__m128i *) &l1[idx1 & 0x1FFFF0], _mm_xor_si128(bx1, cx1)); + + idx0 = EXTRACT64(cx0); + idx1 = EXTRACT64(cx1); + + bx0 = cx0; + bx1 = cx1; + + uint64_t hi, lo, cl, ch; + cl = ((uint64_t*) &l0[idx0 & 0x1FFFF0])[0]; + ch = ((uint64_t*) &l0[idx0 & 0x1FFFF0])[1]; + lo = _umul128(idx0, cl, &hi); + + al0 += hi; + ah0 += lo; + + ((uint64_t*) &l0[idx0 & 0x1FFFF0])[0] = al0; + ((uint64_t*) &l0[idx0 & 0x1FFFF0])[1] = ah0; + + ah0 ^= ch; + al0 ^= cl; + idx0 = al0; + + cl = ((uint64_t*) &l1[idx1 & 0x1FFFF0])[0]; + ch = ((uint64_t*) &l1[idx1 & 0x1FFFF0])[1]; + lo = _umul128(idx1, cl, &hi); + + al1 += hi; + ah1 += lo; + + ((uint64_t*) &l1[idx1 & 0x1FFFF0])[0] = al1; + ((uint64_t*) &l1[idx1 & 0x1FFFF0])[1] = ah1; + + ah1 ^= ch; + al1 ^= cl; + idx1 = al1; + } + + cn_implode_scratchpad((__m128i*) l0, (__m128i*) h0); + cn_implode_scratchpad((__m128i*) l1, (__m128i*) h1); + + keccakf(h0, 24); + keccakf(h1, 24); + + extra_hashes[ctx->state0[0] & 3](ctx->state0, 200, output); + extra_hashes[ctx->state1[0] & 3](ctx->state1, 200, (char*) output + 32); +} diff --git a/algo/cryptonight/cryptonight_softaes.h b/algo/cryptonight/cryptonight_softaes.h new file mode 100644 index 00000000..1948db05 --- /dev/null +++ b/algo/cryptonight/cryptonight_softaes.h @@ -0,0 +1,237 @@ +/* XMRig + * Copyright 2010 Jeff Garzik + * Copyright 2012-2014 pooler + * Copyright 2014 Lucas Jones + * Copyright 2014-2016 Wolf9466 + * Copyright 2016 Jay D Dee + * Copyright 2017 fireice-uk + * Copyright 2016-2017 XMRig + * + * + * 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, either version 3 of the License, or + * (at your option) any later version. + * + * 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, see . + */ + +#ifndef __CRYPTONIGHT_SOFTAES_H__ +#define __CRYPTONIGHT_SOFTAES_H__ + +#include + +extern __m128i soft_aesenc(__m128i in, __m128i key); +extern __m128i soft_aeskeygenassist(__m128i key, uint8_t rcon); + + +// This will shift and xor tmp1 into itself as 4 32-bit vals such as +// sl_xor(a1 a2 a3 a4) = a1 (a2^a1) (a3^a2^a1) (a4^a3^a2^a1) +inline __m128i sl_xor(__m128i tmp1) +{ + __m128i tmp4; + tmp4 = _mm_slli_si128(tmp1, 0x04); + tmp1 = _mm_xor_si128(tmp1, tmp4); + tmp4 = _mm_slli_si128(tmp4, 0x04); + tmp1 = _mm_xor_si128(tmp1, tmp4); + tmp4 = _mm_slli_si128(tmp4, 0x04); + tmp1 = _mm_xor_si128(tmp1, tmp4); + return tmp1; +} + + +inline void aes_genkey_sub(__m128i* xout0, __m128i* xout2, uint8_t rcon) +{ + __m128i xout1 = soft_aeskeygenassist(*xout2, rcon); + xout1 = _mm_shuffle_epi32(xout1, 0xFF); // see PSHUFD, set all elems to 4th elem + *xout0 = sl_xor(*xout0); + *xout0 = _mm_xor_si128(*xout0, xout1); + xout1 = soft_aeskeygenassist(*xout0, 0x00); + xout1 = _mm_shuffle_epi32(xout1, 0xAA); // see PSHUFD, set all elems to 3rd elem + *xout2 = sl_xor(*xout2); + *xout2 = _mm_xor_si128(*xout2, xout1); +} + + +inline void aes_round(__m128i key, __m128i* x0, __m128i* x1, __m128i* x2, __m128i* x3, __m128i* x4, __m128i* x5, __m128i* x6, __m128i* x7) +{ + *x0 = soft_aesenc(*x0, key); + *x1 = soft_aesenc(*x1, key); + *x2 = soft_aesenc(*x2, key); + *x3 = soft_aesenc(*x3, key); + *x4 = soft_aesenc(*x4, key); + *x5 = soft_aesenc(*x5, key); + *x6 = soft_aesenc(*x6, key); + *x7 = soft_aesenc(*x7, key); +} + + +inline void aes_genkey(const __m128i* memory, __m128i* k0, __m128i* k1, __m128i* k2, __m128i* k3, __m128i* k4, __m128i* k5, __m128i* k6, __m128i* k7, __m128i* k8, __m128i* k9) +{ + __m128i xout0 = _mm_load_si128(memory); + __m128i xout2 = _mm_load_si128(memory + 1); + *k0 = xout0; + *k1 = xout2; + + aes_genkey_sub(&xout0, &xout2, 0x1); + *k2 = xout0; + *k3 = xout2; + + aes_genkey_sub(&xout0, &xout2, 0x2); + *k4 = xout0; + *k5 = xout2; + + aes_genkey_sub(&xout0, &xout2, 0x4); + *k6 = xout0; + *k7 = xout2; + + aes_genkey_sub(&xout0, &xout2, 0x8); + *k8 = xout0; + *k9 = xout2; +} + + +inline void cn_explode_scratchpad(const __m128i* input, __m128i* output) +{ + // This is more than we have registers, compiler will assign 2 keys on the stack + __m128i xin0, xin1, xin2, xin3, xin4, xin5, xin6, xin7; + __m128i k0, k1, k2, k3, k4, k5, k6, k7, k8, k9; + + aes_genkey(input, &k0, &k1, &k2, &k3, &k4, &k5, &k6, &k7, &k8, &k9); + + xin0 = _mm_load_si128(input + 4); + xin1 = _mm_load_si128(input + 5); + xin2 = _mm_load_si128(input + 6); + xin3 = _mm_load_si128(input + 7); + xin4 = _mm_load_si128(input + 8); + xin5 = _mm_load_si128(input + 9); + xin6 = _mm_load_si128(input + 10); + xin7 = _mm_load_si128(input + 11); + + for (size_t i = 0; i < MEMORY / sizeof(__m128i); i += 8) { + aes_round(k0, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + aes_round(k1, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + aes_round(k2, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + aes_round(k3, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + aes_round(k4, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + aes_round(k5, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + aes_round(k6, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + aes_round(k7, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + aes_round(k8, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + aes_round(k9, &xin0, &xin1, &xin2, &xin3, &xin4, &xin5, &xin6, &xin7); + + _mm_store_si128(output + i + 0, xin0); + _mm_store_si128(output + i + 1, xin1); + _mm_store_si128(output + i + 2, xin2); + _mm_store_si128(output + i + 3, xin3); + _mm_store_si128(output + i + 4, xin4); + _mm_store_si128(output + i + 5, xin5); + _mm_store_si128(output + i + 6, xin6); + _mm_store_si128(output + i + 7, xin7); + } +} + + +inline void cn_implode_scratchpad(const __m128i* input, __m128i* output) +{ + // This is more than we have registers, compiler will assign 2 keys on the stack + __m128i xout0, xout1, xout2, xout3, xout4, xout5, xout6, xout7; + __m128i k0, k1, k2, k3, k4, k5, k6, k7, k8, k9; + + aes_genkey(output + 2, &k0, &k1, &k2, &k3, &k4, &k5, &k6, &k7, &k8, &k9); + + xout0 = _mm_load_si128(output + 4); + xout1 = _mm_load_si128(output + 5); + xout2 = _mm_load_si128(output + 6); + xout3 = _mm_load_si128(output + 7); + xout4 = _mm_load_si128(output + 8); + xout5 = _mm_load_si128(output + 9); + xout6 = _mm_load_si128(output + 10); + xout7 = _mm_load_si128(output + 11); + + for (size_t i = 0; __builtin_expect(i < MEMORY / sizeof(__m128i), 1); i += 8) + { + xout0 = _mm_xor_si128(_mm_load_si128(input + i + 0), xout0); + xout1 = _mm_xor_si128(_mm_load_si128(input + i + 1), xout1); + xout2 = _mm_xor_si128(_mm_load_si128(input + i + 2), xout2); + xout3 = _mm_xor_si128(_mm_load_si128(input + i + 3), xout3); + xout4 = _mm_xor_si128(_mm_load_si128(input + i + 4), xout4); + xout5 = _mm_xor_si128(_mm_load_si128(input + i + 5), xout5); + xout6 = _mm_xor_si128(_mm_load_si128(input + i + 6), xout6); + xout7 = _mm_xor_si128(_mm_load_si128(input + i + 7), xout7); + + aes_round(k0, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + aes_round(k1, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + aes_round(k2, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + aes_round(k3, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + aes_round(k4, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + aes_round(k5, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + aes_round(k6, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + aes_round(k7, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + aes_round(k8, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + aes_round(k9, &xout0, &xout1, &xout2, &xout3, &xout4, &xout5, &xout6, &xout7); + } + + _mm_store_si128(output + 4, xout0); + _mm_store_si128(output + 5, xout1); + _mm_store_si128(output + 6, xout2); + _mm_store_si128(output + 7, xout3); + _mm_store_si128(output + 8, xout4); + _mm_store_si128(output + 9, xout5); + _mm_store_si128(output + 10, xout6); + _mm_store_si128(output + 11, xout7); +} + + +#if defined(__x86_64__) +# define EXTRACT64(X) _mm_cvtsi128_si64(X) + +inline uint64_t _umul128(uint64_t a, uint64_t b, uint64_t* hi) +{ + unsigned __int128 r = (unsigned __int128) a * (unsigned __int128) b; + *hi = r >> 64; + return (uint64_t) r; +} +#elif defined(__i386__) +# define HI32(X) \ + _mm_srli_si128((X), 4) + + +# define EXTRACT64(X) \ + ((uint64_t)(uint32_t)_mm_cvtsi128_si32(X) | \ + ((uint64_t)(uint32_t)_mm_cvtsi128_si32(HI32(X)) << 32)) + +inline uint64_t _umul128(uint64_t multiplier, uint64_t multiplicand, uint64_t *product_hi) { + // multiplier = ab = a * 2^32 + b + // multiplicand = cd = c * 2^32 + d + // ab * cd = a * c * 2^64 + (a * d + b * c) * 2^32 + b * d + uint64_t a = multiplier >> 32; + uint64_t b = multiplier & 0xFFFFFFFF; + uint64_t c = multiplicand >> 32; + uint64_t d = multiplicand & 0xFFFFFFFF; + + //uint64_t ac = a * c; + uint64_t ad = a * d; + //uint64_t bc = b * c; + uint64_t bd = b * d; + + uint64_t adbc = ad + (b * c); + uint64_t adbc_carry = adbc < ad ? 1 : 0; + + // multiplier * multiplicand = product_hi * 2^64 + product_lo + uint64_t product_lo = bd + (adbc << 32); + uint64_t product_lo_carry = product_lo < bd ? 1 : 0; + *product_hi = (a * c) + (adbc >> 32) + (adbc_carry << 32) + product_lo_carry; + + return product_lo; +} +#endif + + +#endif /* __CRYPTONIGHT_SOFTAES_H__ */ diff --git a/memory.c b/memory.c index 915de32d..49435699 100644 --- a/memory.c +++ b/memory.c @@ -25,6 +25,7 @@ #include "persistent_memory.h" #include "algo/cryptonight/cryptonight.h" +#include "options.h" static size_t offset = 0; @@ -41,7 +42,9 @@ void * persistent_calloc(size_t num, size_t size) { void * create_persistent_ctx(int thr_id) { struct cryptonight_ctx *ctx = (struct cryptonight_ctx *) &persistent_memory[MEMORY - sizeof(struct cryptonight_ctx) * (thr_id + 1)]; - ctx->memory = &persistent_memory[MEMORY * (thr_id + 1)]; + + const int ratio = opt_double_hash ? 2 : 1; + ctx->memory = &persistent_memory[MEMORY * (thr_id * ratio + 1)]; return ctx; } diff --git a/options.c b/options.c index 6a62dd45..7f3de28f 100644 --- a/options.c +++ b/options.c @@ -45,6 +45,7 @@ int opt_donate_level = DONATE_LEVEL; bool opt_colors = true; bool opt_keepalive = false; bool opt_background = false; +bool opt_double_hash = false; char *opt_url = NULL; char *opt_backup_url = NULL; char *opt_userpass = NULL; diff --git a/options.h b/options.h index 22d6d595..dfdf6fbb 100644 --- a/options.h +++ b/options.h @@ -35,10 +35,10 @@ enum xmr_algo_variant { XMR_AV0_AUTO, XMR_AV1_AESNI, - XMR_AV2_STAK, + XMR_AV2_AESNI_DOUBLE, XMR_AV3_AESNI_BMI2, XMR_AV4_SOFT_AES, - XMR_AV5_EXPERIMENTAL, + XMR_AV5_SOFT_AES_DOUBLE, XMR_AV_MAX }; @@ -46,6 +46,7 @@ enum xmr_algo_variant { extern bool opt_colors; extern bool opt_keepalive; extern bool opt_background; +extern bool opt_double_hash; extern char *opt_url; extern char *opt_backup_url; extern char *opt_userpass; diff --git a/unix/memory_unix.c b/unix/memory_unix.c index 76065c0d..bcfbe607 100644 --- a/unix/memory_unix.c +++ b/unix/memory_unix.c @@ -38,7 +38,8 @@ int persistent_memory_flags = 0; const char * persistent_memory_allocate() { - const int size = MEMORY * (opt_n_threads + 1); + const int ratio = opt_double_hash ? 2 : 1; + const int size = MEMORY * (opt_n_threads * ratio + 1); persistent_memory_flags |= MEMORY_HUGEPAGES_AVAILABLE; persistent_memory = mmap(0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_POPULATE, 0, 0); diff --git a/win/memory_win.c b/win/memory_win.c index 877b3cac..6d3cf608 100644 --- a/win/memory_win.c +++ b/win/memory_win.c @@ -85,7 +85,8 @@ static BOOL SetLockPagesPrivilege(HANDLE hProcess, BOOL bEnable) { const char * persistent_memory_allocate() { - const int size = MEMORY * (opt_n_threads + 1); + const int ratio = opt_double_hash ? 2 : 1; + const int size = MEMORY * (opt_n_threads * ratio + 1); if (SetLockPagesPrivilege(GetCurrentProcess(), TRUE)) { persistent_memory_flags |= MEMORY_HUGEPAGES_AVAILABLE; diff --git a/xmrig.c b/xmrig.c index c2d7cee0..13d19b6d 100644 --- a/xmrig.c +++ b/xmrig.c @@ -316,6 +316,94 @@ static void *miner_thread(void *userdata) { } +/** + * @brief miner_thread_double + * @param userdata + * @return + */ +static void *miner_thread_double(void *userdata) { + struct thr_info *mythr = userdata; + const int thr_id = mythr->id; + struct work work = { { 0 } }; + uint32_t max_nonce; + uint32_t end_nonce = 0xffffffffU / opt_n_threads * (thr_id + 1) - 0x20; + + struct cryptonight_ctx *persistentctx = (struct cryptonight_ctx *) create_persistent_ctx(thr_id); + + if (cpu_info.count > 1 && opt_affinity != -1L) { + affine_to_cpu_mask(thr_id, (unsigned long) opt_affinity); + } + + uint32_t *nonceptr0 = NULL; + uint32_t *nonceptr1 = NULL; + uint8_t double_hash[64]; + uint8_t double_blob[sizeof(work.blob) * 2]; + + while (1) { + if (should_pause(thr_id)) { + sleep(1); + continue; + } + + pthread_mutex_lock(&stratum_ctx->work_lock); + + if (memcmp(work.job_id, stratum_ctx->g_work.job_id, 64)) { + work_copy(&work, &stratum_ctx->g_work); + + memcpy(double_blob, work.blob, work.blob_size); + memcpy(double_blob + work.blob_size, work.blob, work.blob_size); + + nonceptr0 = (uint32_t*) (((char*) double_blob) + 39); + nonceptr1 = (uint32_t*) (((char*) double_blob) + 39 + work.blob_size); + + *nonceptr0 = 0xffffffffU / (opt_n_threads * 2) * thr_id; + *nonceptr1 = 0xffffffffU / (opt_n_threads * 2) * (thr_id + opt_n_threads); + } + + pthread_mutex_unlock(&stratum_ctx->work_lock); + + work_restart[thr_id].restart = 0; + + if (*nonceptr0 + (LP_SCANTIME / 2) > end_nonce) { + max_nonce = end_nonce; + } else { + max_nonce = *nonceptr0 + (LP_SCANTIME / 2); + } + + unsigned long hashes_done = 0; + + struct timeval tv_start; + gettimeofday(&tv_start, NULL); + + /* scan nonces for a proof-of-work hash */ + const int rc = scanhash_cryptonight_double(thr_id, (uint32_t *) double_hash, double_blob, work.blob_size, work.target, max_nonce, &hashes_done, persistentctx); + stats_add_hashes(thr_id, &tv_start, hashes_done); + + if (!rc) { + continue; + } + + if (rc & 1) { + memcpy(work.hash, double_hash, 32); + memcpy(work.blob, double_blob, work.blob_size); + submit_work(mythr, &work); + } + + if (rc & 2) { + memcpy(work.hash, double_hash + 32, 32); + memcpy(work.blob, double_blob + work.blob_size, work.blob_size); + submit_work(mythr, &work); + } + + ++(*nonceptr0); + ++(*nonceptr1); + } + + tq_freeze(mythr->q); + return NULL; +} + + /** * @brief stratum_thread @@ -522,7 +610,7 @@ static bool start_mining() { thr->id = i; thr->q = tq_new(); - if (unlikely(!thr->q || pthread_create(&thr->pth, NULL, miner_thread, thr))) { + if (unlikely(!thr->q || pthread_create(&thr->pth, NULL, opt_double_hash ? miner_thread_double : miner_thread, thr))) { applog(LOG_ERR, "thread %d create failed", i); return false; }