Implement low power mode (double hash).

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)
-
+    add_executable(xmrig ${HEADERS} ${HEADERS_CRYPTO} ${SOURCES} ${SOURCES_CRYPTO} ${HEADERS_UTILS} ${SOURCES_UTILS} ${HEADERS_COMPAT} ${SOURCES_COMPAT} ${SOURCES_OS})
-    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})
     target_link_libraries(xmrig jansson curl cryptonight_av3_aesni_bmi2 ${EXTRA_LIBS})
 else()
     set(CRYPTONIGHT32

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_AESNI_DOUBLE:
-        case XMR_AV2_STAK:
+            opt_double_hash = true;
-            cryptonight_hash_ctx = cryptonight_av2_aesni_stak;
+            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;
+            cryptonight_hash_ctx = cryptonight_av4_softaes;
-             break;
+            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

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 state0[200] __attribute__((aligned(16)));
-    uint8_t* memory    __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__ */

algo/cryptonight/cryptonight_aesni.h

@@ -22,8 +22,8 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef __CRYPTONIGHT_P_H__
+#ifndef __CRYPTONIGHT_AESNI_H__
-#define __CRYPTONIGHT_P_H__
+#define __CRYPTONIGHT_AESNI_H__
 
 #include <x86intrin.h>
 
@@ -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__ */

algo/cryptonight/cryptonight_av1_aesni.c

@@ -26,18 +26,18 @@
 #include <string.h>
 
 #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);
 }

algo/cryptonight/cryptonight_av2_aesni_double.c

@@ -0,0 +1,111 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017      fireice-uk  <https://github.com/fireice-uk>
+ * Copyright 2016-2017 XMRig       <support@xmrig.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, 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <x86intrin.h>
+#include <string.h>
+
+#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);
+}

algo/cryptonight/cryptonight_av2_aesni_stak.c

@@ -1,77 +0,0 @@
-/* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
- * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
- * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
- * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
- * Copyright 2017      fireice-uk  <https://github.com/fireice-uk>
- * Copyright 2016-2017 XMRig       <support@xmrig.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, 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 <http://www.gnu.org/licenses/>.
- */
-
-#include <x86intrin.h>
-#include <string.h>
-
-#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);
-}

algo/cryptonight/cryptonight_av3_aesni_bmi2.c

@@ -26,18 +26,18 @@
 #include <string.h>
 
 #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);
 }

algo/cryptonight/cryptonight_av4_softaes.c

@@ -26,191 +26,18 @@
 #include <string.h>
 
 #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);
 }

algo/cryptonight/cryptonight_av5_aesni_experimental.c

@@ -1,77 +0,0 @@
-/* XMRig
- * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
- * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
- * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
- * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
- * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
- * Copyright 2017      fireice-uk  <https://github.com/fireice-uk>
- * Copyright 2016-2017 XMRig       <support@xmrig.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, 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 <http://www.gnu.org/licenses/>.
- */
-
-#include <x86intrin.h>
-#include <string.h>
-
-#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);
-}

algo/cryptonight/cryptonight_av5_softaes_double.c

@@ -0,0 +1,111 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017      fireice-uk  <https://github.com/fireice-uk>
+ * Copyright 2016-2017 XMRig       <support@xmrig.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, 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <x86intrin.h>
+#include <string.h>
+
+#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);
+}

algo/cryptonight/cryptonight_softaes.h

@@ -0,0 +1,237 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017      fireice-uk  <https://github.com/fireice-uk>
+ * Copyright 2016-2017 XMRig       <support@xmrig.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, 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 <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __CRYPTONIGHT_SOFTAES_H__
+#define __CRYPTONIGHT_SOFTAES_H__
+
+#include <x86intrin.h>
+
+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__ */

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;
 }

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;

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;

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);

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;

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;
         }