diff --git a/xmrstak/backend/cpu/autoAdjust.hpp b/xmrstak/backend/cpu/autoAdjust.hpp
index 294bc6fff33210b61bbe61e785516fc7a3ab14fa..e7d6eecd6f5bcaa94bad9f6fc519c6169ad9608e 100644
--- a/xmrstak/backend/cpu/autoAdjust.hpp
+++ b/xmrstak/backend/cpu/autoAdjust.hpp
@@ -6,6 +6,7 @@
#include "xmrstak/jconf.hpp"
#include "xmrstak/misc/configEditor.hpp"
#include "xmrstak/params.hpp"
+#include "../cryptonight.hpp"
#include <string>
#ifdef _WIN32
@@ -32,8 +33,21 @@ class autoAdjust
{
public:
+ size_t hashMemSize;
+ size_t halfHashMemSize;
+
autoAdjust()
{
+ if(::jconf::inst()->IsCurrencyXMR())
+ {
+ hashMemSize = XMR_MEMORY;
+ halfHashMemSize = hashMemSize / 2u;
+ }
+ else
+ {
+ hashMemSize = AEON_MEMORY;
+ halfHashMemSize = hashMemSize / 2u;
+ }
}
bool printConfig()
@@ -49,9 +63,9 @@ public:
std::string conf;
- if(!detectL3Size() || L3KB_size < 1024 || L3KB_size > 102400)
+ if(!detectL3Size() || L3KB_size < halfHashMemSize || L3KB_size > (halfHashMemSize * 100u))
{
- if(L3KB_size < 1024 || L3KB_size > 102400)
+ if(L3KB_size < halfHashMemSize || L3KB_size > (halfHashMemSize * 100))
printer::inst()->print_msg(L0, "Autoconf failed: L3 size sanity check failed - %u KB.", L3KB_size);
conf += std::string(" { \"low_power_mode\" : false, \"no_prefetch\" : true, \"affine_to_cpu\" : false },\n");
@@ -74,7 +88,7 @@ public:
if(L3KB_size <= 0)
break;
- double_mode = L3KB_size / 2048 > (int32_t)(corecnt-i);
+ double_mode = L3KB_size / hashMemSize > (int32_t)(corecnt-i);
conf += std::string(" { \"low_power_mode\" : ");
conf += std::string(double_mode ? "true" : "false");
@@ -93,9 +107,9 @@ public:
aff_id++;
if(double_mode)
- L3KB_size -= 4096;
+ L3KB_size -= hashMemSize * 2u;
else
- L3KB_size -= 2048;
+ L3KB_size -= hashMemSize;
}
}
@@ -128,7 +142,7 @@ private:
}
L3KB_size = ((get_masked(cpu_info[1], 31, 22) + 1) * (get_masked(cpu_info[1], 21, 12) + 1) *
- (get_masked(cpu_info[1], 11, 0) + 1) * (cpu_info[2] + 1)) / 1024;
+ (get_masked(cpu_info[1], 11, 0) + 1) * (cpu_info[2] + 1)) / halfHashMemSize;
return true;
}
diff --git a/xmrstak/backend/cpu/autoAdjustHwloc.hpp b/xmrstak/backend/cpu/autoAdjustHwloc.hpp
index ad3b8639ac7764bd8620067aefd17c2ccfe33f92..b6f84c482a23b16650c18835f2c304ec087f13c5 100644
--- a/xmrstak/backend/cpu/autoAdjustHwloc.hpp
+++ b/xmrstak/backend/cpu/autoAdjustHwloc.hpp
@@ -3,6 +3,7 @@
#include "xmrstak/misc/console.hpp"
#include "xmrstak/misc/configEditor.hpp"
#include "xmrstak/params.hpp"
+#include "../cryptonight.hpp"
#ifdef _WIN32
#include <windows.h>
@@ -27,6 +28,16 @@ public:
autoAdjust()
{
+ if(::jconf::inst()->IsCurrencyXMR())
+ {
+ hashMemSize = XMR_MEMORY;
+ halfHashMemSize = hashMemSize / 2u;
+ }
+ else
+ {
+ hashMemSize = AEON_MEMORY;
+ halfHashMemSize = hashMemSize / 2u;
+ }
}
bool printConfig()
@@ -86,7 +97,9 @@ public:
}
private:
- static constexpr size_t hashSize = 2 * 1024 * 1024;
+ size_t hashMemSize;
+ size_t halfHashMemSize;
+
std::vector<uint32_t> results;
template<typename func>
@@ -161,8 +174,8 @@ private:
{
hwloc_obj_t l2obj = obj->children[i];
//If L2 is exclusive and greater or equal to 2MB add room for one more hash
- if(isCacheObject(l2obj) && l2obj->attr != nullptr && l2obj->attr->cache.size >= hashSize)
- cacheSize += hashSize;
+ if(isCacheObject(l2obj) && l2obj->attr != nullptr && l2obj->attr->cache.size >= hashMemSize)
+ cacheSize += hashMemSize;
}
}
@@ -170,7 +183,7 @@ private:
cores.reserve(16);
findChildrenByType(obj, HWLOC_OBJ_CORE, [&cores](hwloc_obj_t found) { cores.emplace_back(found); } );
- size_t cacheHashes = (cacheSize + hashSize/2) / hashSize;
+ size_t cacheHashes = (cacheSize + halfHashMemSize) / hashMemSize;
//Firstly allocate PU 0 of every CORE, then PU 1 etc.
size_t pu_id = 0;
diff --git a/xmrstak/backend/cpu/crypto/cryptonight.h b/xmrstak/backend/cpu/crypto/cryptonight.h
index 978c798aea916fdd03d830129d39750908c6b485..d07050e4bc64a0f9de135a8c0285a42d4e437878 100644
--- a/xmrstak/backend/cpu/crypto/cryptonight.h
+++ b/xmrstak/backend/cpu/crypto/cryptonight.h
@@ -7,8 +7,8 @@ extern "C" {
#include <stddef.h>
#include <inttypes.h>
+#include "../../cryptonight.hpp"
-#define MEMORY 2097152
typedef struct {
uint8_t hash_state[224]; // Need only 200, explicit align
diff --git a/xmrstak/backend/cpu/crypto/cryptonight_aesni.h b/xmrstak/backend/cpu/crypto/cryptonight_aesni.h
index 942d51151db6280f17caa901e7d114cb514cb92f..2a6a7695dadaa36ee267a973b7acb1244b7028f9 100644
--- a/xmrstak/backend/cpu/crypto/cryptonight_aesni.h
+++ b/xmrstak/backend/cpu/crypto/cryptonight_aesni.h
@@ -287,7 +287,7 @@ void cn_implode_scratchpad(const __m128i* input, __m128i* output)
_mm_store_si128(output + 11, xout7);
}
-template<size_t ITERATIONS, size_t MEM, bool SOFT_AES, bool PREFETCH>
+template<size_t MASK, size_t ITERATIONS, size_t MEM, bool SOFT_AES, bool PREFETCH>
void cryptonight_hash(const void* input, size_t len, void* output, cryptonight_ctx* ctx0)
{
keccak((const uint8_t *)input, len, ctx0->hash_state, 200);
@@ -308,36 +308,36 @@ void cryptonight_hash(const void* input, size_t len, void* output, cryptonight_c
for(size_t i = 0; i < ITERATIONS; i++)
{
__m128i cx;
- cx = _mm_load_si128((__m128i *)&l0[idx0 & 0x1FFFF0]);
+ cx = _mm_load_si128((__m128i *)&l0[idx0 & MASK]);
if(SOFT_AES)
cx = soft_aesenc(cx, _mm_set_epi64x(ah0, al0));
else
cx = _mm_aesenc_si128(cx, _mm_set_epi64x(ah0, al0));
- _mm_store_si128((__m128i *)&l0[idx0 & 0x1FFFF0], _mm_xor_si128(bx0, cx));
+ _mm_store_si128((__m128i *)&l0[idx0 & MASK], _mm_xor_si128(bx0, cx));
idx0 = _mm_cvtsi128_si64(cx);
bx0 = cx;
if(PREFETCH)
- _mm_prefetch((const char*)&l0[idx0 & 0x1FFFF0], _MM_HINT_T0);
+ _mm_prefetch((const char*)&l0[idx0 & MASK], _MM_HINT_T0);
uint64_t hi, lo, cl, ch;
- cl = ((uint64_t*)&l0[idx0 & 0x1FFFF0])[0];
- ch = ((uint64_t*)&l0[idx0 & 0x1FFFF0])[1];
+ cl = ((uint64_t*)&l0[idx0 & MASK])[0];
+ ch = ((uint64_t*)&l0[idx0 & MASK])[1];
lo = _umul128(idx0, cl, &hi);
al0 += hi;
ah0 += lo;
- ((uint64_t*)&l0[idx0 & 0x1FFFF0])[0] = al0;
- ((uint64_t*)&l0[idx0 & 0x1FFFF0])[1] = ah0;
+ ((uint64_t*)&l0[idx0 & MASK])[0] = al0;
+ ((uint64_t*)&l0[idx0 & MASK])[1] = ah0;
ah0 ^= ch;
al0 ^= cl;
idx0 = al0;
if(PREFETCH)
- _mm_prefetch((const char*)&l0[idx0 & 0x1FFFF0], _MM_HINT_T0);
+ _mm_prefetch((const char*)&l0[idx0 & MASK], _MM_HINT_T0);
}
// Optim - 90% time boundary
@@ -352,7 +352,7 @@ void cryptonight_hash(const void* input, size_t len, void* output, cryptonight_c
// This lovely creation will do 2 cn hashes at a time. We have plenty of space on silicon
// to fit temporary vars for two contexts. Function will read len*2 from input and write 64 bytes to output
// We are still limited by L3 cache, so doubling will only work with CPUs where we have more than 2MB to core (Xeons)
-template<size_t ITERATIONS, size_t MEM, bool SOFT_AES, bool PREFETCH>
+template<size_t MASK, size_t ITERATIONS, size_t MEM, bool SOFT_AES, bool PREFETCH>
void cryptonight_double_hash(const void* input, size_t len, void* output, cryptonight_ctx* __restrict ctx0, cryptonight_ctx* __restrict ctx1)
{
keccak((const uint8_t *)input, len, ctx0->hash_state, 200);
@@ -381,66 +381,66 @@ void cryptonight_double_hash(const void* input, size_t len, void* output, crypto
for (size_t i = 0; i < ITERATIONS; i++)
{
__m128i cx;
- cx = _mm_load_si128((__m128i *)&l0[idx0 & 0x1FFFF0]);
+ cx = _mm_load_si128((__m128i *)&l0[idx0 & MASK]);
if(SOFT_AES)
cx = soft_aesenc(cx, _mm_set_epi64x(axh0, axl0));
else
cx = _mm_aesenc_si128(cx, _mm_set_epi64x(axh0, axl0));
- _mm_store_si128((__m128i *)&l0[idx0 & 0x1FFFF0], _mm_xor_si128(bx0, cx));
+ _mm_store_si128((__m128i *)&l0[idx0 & MASK], _mm_xor_si128(bx0, cx));
idx0 = _mm_cvtsi128_si64(cx);
bx0 = cx;
if(PREFETCH)
- _mm_prefetch((const char*)&l0[idx0 & 0x1FFFF0], _MM_HINT_T0);
+ _mm_prefetch((const char*)&l0[idx0 & MASK], _MM_HINT_T0);
- cx = _mm_load_si128((__m128i *)&l1[idx1 & 0x1FFFF0]);
+ cx = _mm_load_si128((__m128i *)&l1[idx1 & MASK]);
if(SOFT_AES)
cx = soft_aesenc(cx, _mm_set_epi64x(axh1, axl1));
else
cx = _mm_aesenc_si128(cx, _mm_set_epi64x(axh1, axl1));
- _mm_store_si128((__m128i *)&l1[idx1 & 0x1FFFF0], _mm_xor_si128(bx1, cx));
+ _mm_store_si128((__m128i *)&l1[idx1 & MASK], _mm_xor_si128(bx1, cx));
idx1 = _mm_cvtsi128_si64(cx);
bx1 = cx;
if(PREFETCH)
- _mm_prefetch((const char*)&l1[idx1 & 0x1FFFF0], _MM_HINT_T0);
+ _mm_prefetch((const char*)&l1[idx1 & MASK], _MM_HINT_T0);
uint64_t hi, lo, cl, ch;
- cl = ((uint64_t*)&l0[idx0 & 0x1FFFF0])[0];
- ch = ((uint64_t*)&l0[idx0 & 0x1FFFF0])[1];
+ cl = ((uint64_t*)&l0[idx0 & MASK])[0];
+ ch = ((uint64_t*)&l0[idx0 & MASK])[1];
lo = _umul128(idx0, cl, &hi);
axl0 += hi;
axh0 += lo;
- ((uint64_t*)&l0[idx0 & 0x1FFFF0])[0] = axl0;
- ((uint64_t*)&l0[idx0 & 0x1FFFF0])[1] = axh0;
+ ((uint64_t*)&l0[idx0 & MASK])[0] = axl0;
+ ((uint64_t*)&l0[idx0 & MASK])[1] = axh0;
axh0 ^= ch;
axl0 ^= cl;
idx0 = axl0;
if(PREFETCH)
- _mm_prefetch((const char*)&l0[idx0 & 0x1FFFF0], _MM_HINT_T0);
+ _mm_prefetch((const char*)&l0[idx0 & MASK], _MM_HINT_T0);
- cl = ((uint64_t*)&l1[idx1 & 0x1FFFF0])[0];
- ch = ((uint64_t*)&l1[idx1 & 0x1FFFF0])[1];
+ cl = ((uint64_t*)&l1[idx1 & MASK])[0];
+ ch = ((uint64_t*)&l1[idx1 & MASK])[1];
lo = _umul128(idx1, cl, &hi);
axl1 += hi;
axh1 += lo;
- ((uint64_t*)&l1[idx1 & 0x1FFFF0])[0] = axl1;
- ((uint64_t*)&l1[idx1 & 0x1FFFF0])[1] = axh1;
+ ((uint64_t*)&l1[idx1 & MASK])[0] = axl1;
+ ((uint64_t*)&l1[idx1 & MASK])[1] = axh1;
axh1 ^= ch;
axl1 ^= cl;
idx1 = axl1;
if(PREFETCH)
- _mm_prefetch((const char*)&l1[idx1 & 0x1FFFF0], _MM_HINT_T0);
+ _mm_prefetch((const char*)&l1[idx1 & MASK], _MM_HINT_T0);
}
// Optim - 90% time boundary
diff --git a/xmrstak/backend/cpu/crypto/cryptonight_common.cpp b/xmrstak/backend/cpu/crypto/cryptonight_common.cpp
index 0690415e644779c466b3233b3753235e28e0f565..70ad27c6eaa85bd392ce6ae48103b5a9fa7de1c2 100644
--- a/xmrstak/backend/cpu/crypto/cryptonight_common.cpp
+++ b/xmrstak/backend/cpu/crypto/cryptonight_common.cpp
@@ -30,6 +30,8 @@ extern "C"
}
#include "cryptonight.h"
#include "cryptonight_aesni.h"
+#include "../../../jconf.hpp"
+#include "../../cryptonight.hpp"
#include <stdio.h>
#include <stdlib.h>
@@ -194,12 +196,21 @@ size_t cryptonight_init(size_t use_fast_mem, size_t use_mlock, alloc_msg* msg)
cryptonight_ctx* cryptonight_alloc_ctx(size_t use_fast_mem, size_t use_mlock, alloc_msg* msg)
{
+ size_t hashMemSize;
+ if(::jconf::inst()->IsCurrencyXMR())
+ {
+ hashMemSize = XMR_MEMORY;
+ }
+ else
+ {
+ hashMemSize = AEON_MEMORY;
+ }
cryptonight_ctx* ptr = (cryptonight_ctx*)_mm_malloc(sizeof(cryptonight_ctx), 4096);
if(use_fast_mem == 0)
{
// use 2MiB aligned memory
- ptr->long_state = (uint8_t*)_mm_malloc(MEMORY, 2*1024*1024);
+ ptr->long_state = (uint8_t*)_mm_malloc(hashMemSize, hashMemSize);
ptr->ctx_info[0] = 0;
ptr->ctx_info[1] = 0;
return ptr;
@@ -208,7 +219,7 @@ cryptonight_ctx* cryptonight_alloc_ctx(size_t use_fast_mem, size_t use_mlock, al
#ifdef _WIN32
SIZE_T iLargePageMin = GetLargePageMinimum();
- if(MEMORY > iLargePageMin)
+ if(hashMemSize > iLargePageMin)
iLargePageMin *= 2;
ptr->long_state = (uint8_t*)VirtualAlloc(NULL, iLargePageMin,
@@ -231,13 +242,13 @@ cryptonight_ctx* cryptonight_alloc_ctx(size_t use_fast_mem, size_t use_mlock, al
#else
#if defined(__APPLE__)
- ptr->long_state = (uint8_t*)mmap(0, MEMORY, PROT_READ | PROT_WRITE,
+ ptr->long_state = (uint8_t*)mmap(0, hashMemSize, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, VM_FLAGS_SUPERPAGE_SIZE_2MB, 0);
#elif defined(__FreeBSD__)
- ptr->long_state = (uint8_t*)mmap(0, MEMORY, PROT_READ | PROT_WRITE,
+ ptr->long_state = (uint8_t*)mmap(0, hashMemSize, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_ALIGNED_SUPER | MAP_PREFAULT_READ, -1, 0);
#else
- ptr->long_state = (uint8_t*)mmap(0, MEMORY, PROT_READ | PROT_WRITE,
+ ptr->long_state = (uint8_t*)mmap(0, hashMemSize, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_POPULATE, 0, 0);
#endif
@@ -250,11 +261,11 @@ cryptonight_ctx* cryptonight_alloc_ctx(size_t use_fast_mem, size_t use_mlock, al
ptr->ctx_info[0] = 1;
- if(madvise(ptr->long_state, MEMORY, MADV_RANDOM|MADV_WILLNEED) != 0)
+ if(madvise(ptr->long_state, hashMemSize, MADV_RANDOM|MADV_WILLNEED) != 0)
msg->warning = "madvise failed";
ptr->ctx_info[1] = 0;
- if(use_mlock != 0 && mlock(ptr->long_state, MEMORY) != 0)
+ if(use_mlock != 0 && mlock(ptr->long_state, hashMemSize) != 0)
msg->warning = "mlock failed";
else
ptr->ctx_info[1] = 1;
@@ -265,14 +276,23 @@ cryptonight_ctx* cryptonight_alloc_ctx(size_t use_fast_mem, size_t use_mlock, al
void cryptonight_free_ctx(cryptonight_ctx* ctx)
{
+ size_t hashMemSize;
+ if(::jconf::inst()->IsCurrencyXMR())
+ {
+ hashMemSize = XMR_MEMORY;
+ }
+ else
+ {
+ hashMemSize = AEON_MEMORY;
+ }
if(ctx->ctx_info[0] != 0)
{
#ifdef _WIN32
VirtualFree(ctx->long_state, 0, MEM_RELEASE);
#else
if(ctx->ctx_info[1] != 0)
- munlock(ctx->long_state, MEMORY);
- munmap(ctx->long_state, MEMORY);
+ munlock(ctx->long_state, hashMemSize);
+ munmap(ctx->long_state, hashMemSize);
#endif // _WIN32
}
else
diff --git a/xmrstak/backend/cpu/minethd.cpp b/xmrstak/backend/cpu/minethd.cpp
index 1524eca9240f34f1230b0c0a81c4e8d2593983f1..28d641caa922f486afa8a2fea57ca51993122458 100644
--- a/xmrstak/backend/cpu/minethd.cpp
+++ b/xmrstak/backend/cpu/minethd.cpp
@@ -199,30 +199,34 @@ bool minethd::self_test()
return false;
}
- unsigned char out[64];
- bool bResult;
+ bool bResult = true;
- cn_hash_fun hashf;
- cn_hash_fun_dbl hashdf;
+ bool useXmr = ::jconf::inst()->IsCurrencyXMR();
+ if(useXmr)
+ {
+ unsigned char out[64];
+ cn_hash_fun hashf;
+ cn_hash_fun_dbl hashdf;
- hashf = func_selector(::jconf::inst()->HaveHardwareAes(), false);
- hashf("This is a test", 14, out, ctx0);
- bResult = memcmp(out, "\xa0\x84\xf0\x1d\x14\x37\xa0\x9c\x69\x85\x40\x1b\x60\xd4\x35\x54\xae\x10\x58\x02\xc5\xf5\xd8\xa9\xb3\x25\x36\x49\xc0\xbe\x66\x05", 32) == 0;
- hashf = func_selector(::jconf::inst()->HaveHardwareAes(), true);
- hashf("This is a test", 14, out, ctx0);
- bResult &= memcmp(out, "\xa0\x84\xf0\x1d\x14\x37\xa0\x9c\x69\x85\x40\x1b\x60\xd4\x35\x54\xae\x10\x58\x02\xc5\xf5\xd8\xa9\xb3\x25\x36\x49\xc0\xbe\x66\x05", 32) == 0;
+ hashf = func_selector(::jconf::inst()->HaveHardwareAes(), false, useXmr);
+ hashf("This is a test", 14, out, ctx0);
+ bResult = memcmp(out, "\xa0\x84\xf0\x1d\x14\x37\xa0\x9c\x69\x85\x40\x1b\x60\xd4\x35\x54\xae\x10\x58\x02\xc5\xf5\xd8\xa9\xb3\x25\x36\x49\xc0\xbe\x66\x05", 32) == 0;
- hashdf = func_dbl_selector(::jconf::inst()->HaveHardwareAes(), false);
- hashdf("The quick brown fox jumps over the lazy dogThe quick brown fox jumps over the lazy log", 43, out, ctx0, ctx1);
- bResult &= memcmp(out, "\x3e\xbb\x7f\x9f\x7d\x27\x3d\x7c\x31\x8d\x86\x94\x77\x55\x0c\xc8\x00\xcf\xb1\x1b\x0c\xad\xb7\xff\xbd\xf6\xf8\x9f\x3a\x47\x1c\x59"
- "\xb4\x77\xd5\x02\xe4\xd8\x48\x7f\x42\xdf\xe3\x8e\xed\x73\x81\x7a\xda\x91\xb7\xe2\x63\xd2\x91\x71\xb6\x5c\x44\x3a\x01\x2a\x41\x22", 64) == 0;
+ hashf = func_selector(::jconf::inst()->HaveHardwareAes(), true, useXmr);
+ hashf("This is a test", 14, out, ctx0);
+ bResult &= memcmp(out, "\xa0\x84\xf0\x1d\x14\x37\xa0\x9c\x69\x85\x40\x1b\x60\xd4\x35\x54\xae\x10\x58\x02\xc5\xf5\xd8\xa9\xb3\x25\x36\x49\xc0\xbe\x66\x05", 32) == 0;
- hashdf = func_dbl_selector(::jconf::inst()->HaveHardwareAes(), true);
- hashdf("The quick brown fox jumps over the lazy dogThe quick brown fox jumps over the lazy log", 43, out, ctx0, ctx1);
- bResult &= memcmp(out, "\x3e\xbb\x7f\x9f\x7d\x27\x3d\x7c\x31\x8d\x86\x94\x77\x55\x0c\xc8\x00\xcf\xb1\x1b\x0c\xad\xb7\xff\xbd\xf6\xf8\x9f\x3a\x47\x1c\x59"
- "\xb4\x77\xd5\x02\xe4\xd8\x48\x7f\x42\xdf\xe3\x8e\xed\x73\x81\x7a\xda\x91\xb7\xe2\x63\xd2\x91\x71\xb6\x5c\x44\x3a\x01\x2a\x41\x22", 64) == 0;
+ hashdf = func_dbl_selector(::jconf::inst()->HaveHardwareAes(), false, useXmr);
+ hashdf("The quick brown fox jumps over the lazy dogThe quick brown fox jumps over the lazy log", 43, out, ctx0, ctx1);
+ bResult &= memcmp(out, "\x3e\xbb\x7f\x9f\x7d\x27\x3d\x7c\x31\x8d\x86\x94\x77\x55\x0c\xc8\x00\xcf\xb1\x1b\x0c\xad\xb7\xff\xbd\xf6\xf8\x9f\x3a\x47\x1c\x59"
+ "\xb4\x77\xd5\x02\xe4\xd8\x48\x7f\x42\xdf\xe3\x8e\xed\x73\x81\x7a\xda\x91\xb7\xe2\x63\xd2\x91\x71\xb6\x5c\x44\x3a\x01\x2a\x41\x22", 64) == 0;
+ hashdf = func_dbl_selector(::jconf::inst()->HaveHardwareAes(), true, useXmr);
+ hashdf("The quick brown fox jumps over the lazy dogThe quick brown fox jumps over the lazy log", 43, out, ctx0, ctx1);
+ bResult &= memcmp(out, "\x3e\xbb\x7f\x9f\x7d\x27\x3d\x7c\x31\x8d\x86\x94\x77\x55\x0c\xc8\x00\xcf\xb1\x1b\x0c\xad\xb7\xff\xbd\xf6\xf8\x9f\x3a\x47\x1c\x59"
+ "\xb4\x77\xd5\x02\xe4\xd8\x48\x7f\x42\xdf\xe3\x8e\xed\x73\x81\x7a\xda\x91\xb7\xe2\x63\xd2\x91\x71\xb6\x5c\x44\x3a\x01\x2a\x41\x22", 64) == 0;
+ }
cryptonight_free_ctx(ctx0);
cryptonight_free_ctx(ctx1);
@@ -285,23 +289,43 @@ void minethd::consume_work()
globalStates::inst().inst().iConsumeCnt++;
}
-minethd::cn_hash_fun minethd::func_selector(bool bHaveAes, bool bNoPrefetch)
+minethd::cn_hash_fun minethd::func_selector(bool bHaveAes, bool bNoPrefetch, bool useXMR)
{
// We have two independent flag bits in the functions
// therefore we will build a binary digit and select the
// function as a two digit binary
- // Digit order SOFT_AES, NO_PREFETCH
-
- static const cn_hash_fun func_table[4] = {
- cryptonight_hash<0x80000, MEMORY, false, false>,
- cryptonight_hash<0x80000, MEMORY, false, true>,
- cryptonight_hash<0x80000, MEMORY, true, false>,
- cryptonight_hash<0x80000, MEMORY, true, true>
+ // Digit order SOFT_AES, NO_PREFETCH, MINER_ALGO
+
+ static const cn_hash_fun func_table[] = {
+#ifndef CONF_NO_XMR
+ cryptonight_hash<XMR_MASK, XMR_ITER, XMR_MEMORY, false, false>,
+ cryptonight_hash<XMR_MASK, XMR_ITER, XMR_MEMORY, false, true>,
+ cryptonight_hash<XMR_MASK, XMR_ITER, XMR_MEMORY, true, false>,
+ cryptonight_hash<XMR_MASK, XMR_ITER, XMR_MEMORY, true, true>
+#endif
+#if (!defined(CONF_NO_AEON)) && (!defined(CONF_NO_XMR))
+ ,
+#endif
+#ifndef CONF_NO_AEON
+ cryptonight_hash<AEON_MASK, AEON_ITER, AEON_MEMORY, false, false>,
+ cryptonight_hash<AEON_MASK, AEON_ITER, AEON_MEMORY, false, true>,
+ cryptonight_hash<AEON_MASK, AEON_ITER, AEON_MEMORY, true, false>,
+ cryptonight_hash<AEON_MASK, AEON_ITER, AEON_MEMORY, true, true>
+#endif
};
- std::bitset<2> digit;
+ std::bitset<3> digit;
digit.set(0, !bNoPrefetch);
digit.set(1, !bHaveAes);
+ //miner algo true = XMR, false = AEON
+ digit.set(2, useXMR);
+
+ // define aeon settings
+#if defined(CONF_NO_AEON) || defined(CONF_NO_XMR)
+ digit.set(2, 0);
+#else
+ digit.set(2, !useXMR);
+#endif
return func_table[digit.to_ulong()];
}
@@ -320,7 +344,7 @@ void minethd::work_main()
uint32_t* piNonce;
job_result result;
- hash_fun = func_selector(::jconf::inst()->HaveHardwareAes(), bNoPrefetch);
+ hash_fun = func_selector(::jconf::inst()->HaveHardwareAes(), bNoPrefetch, ::jconf::inst()->IsCurrencyXMR());
ctx = minethd_alloc_ctx();
piHashVal = (uint64_t*)(result.bResult + 24);
@@ -382,23 +406,43 @@ void minethd::work_main()
cryptonight_free_ctx(ctx);
}
-minethd::cn_hash_fun_dbl minethd::func_dbl_selector(bool bHaveAes, bool bNoPrefetch)
+minethd::cn_hash_fun_dbl minethd::func_dbl_selector(bool bHaveAes, bool bNoPrefetch, bool useXMR)
{
// We have two independent flag bits in the functions
// therefore we will build a binary digit and select the
// function as a two digit binary
- // Digit order SOFT_AES, NO_PREFETCH
-
- static const cn_hash_fun_dbl func_table[4] = {
- cryptonight_double_hash<0x80000, MEMORY, false, false>,
- cryptonight_double_hash<0x80000, MEMORY, false, true>,
- cryptonight_double_hash<0x80000, MEMORY, true, false>,
- cryptonight_double_hash<0x80000, MEMORY, true, true>
+ // Digit order SOFT_AES, NO_PREFETCH, MINER_ALGO
+
+ static const cn_hash_fun_dbl func_table[] = {
+#ifndef CONF_NO_XMR
+ cryptonight_double_hash<XMR_MASK, XMR_ITER, XMR_MEMORY, false, false>,
+ cryptonight_double_hash<XMR_MASK, XMR_ITER, XMR_MEMORY, false, true>,
+ cryptonight_double_hash<XMR_MASK, XMR_ITER, XMR_MEMORY, true, false>,
+ cryptonight_double_hash<XMR_MASK, XMR_ITER, XMR_MEMORY, true, true>
+#endif
+#if (!defined(CONF_NO_AEON)) && (!defined(CONF_NO_XMR))
+ ,
+#endif
+#ifndef CONF_NO_AEON
+ cryptonight_double_hash<AEON_MASK, AEON_ITER, AEON_MEMORY, false, false>,
+ cryptonight_double_hash<AEON_MASK, AEON_ITER, AEON_MEMORY, false, true>,
+ cryptonight_double_hash<AEON_MASK, AEON_ITER, AEON_MEMORY, true, false>,
+ cryptonight_double_hash<AEON_MASK, AEON_ITER, AEON_MEMORY, true, true>
+#endif
};
- std::bitset<2> digit;
+ std::bitset<3> digit;
digit.set(0, !bNoPrefetch);
digit.set(1, !bHaveAes);
+ //miner algo true = XMR, false = AEON
+ digit.set(2, useXMR);
+
+ // define aeon settings
+#if defined(CONF_NO_AEON) || defined(CONF_NO_XMR)
+ digit.set(2, 0);
+#else
+ digit.set(2, !useXMR);
+#endif
return func_table[digit.to_ulong()];
}
@@ -428,7 +472,7 @@ void minethd::double_work_main()
uint32_t iNonce;
job_result res;
- hash_fun = func_dbl_selector(::jconf::inst()->HaveHardwareAes(), bNoPrefetch);
+ hash_fun = func_dbl_selector(::jconf::inst()->HaveHardwareAes(), bNoPrefetch, ::jconf::inst()->IsCurrencyXMR());
ctx0 = minethd_alloc_ctx();
ctx1 = minethd_alloc_ctx();
diff --git a/xmrstak/backend/cpu/minethd.hpp b/xmrstak/backend/cpu/minethd.hpp
index 5ffd44e19e3040d69a42ee346849d1544fa7007a..5bd8a4f95edb74d142454793b8432f059c33f345 100644
--- a/xmrstak/backend/cpu/minethd.hpp
+++ b/xmrstak/backend/cpu/minethd.hpp
@@ -23,7 +23,7 @@ public:
typedef void (*cn_hash_fun)(const void*, size_t, void*, cryptonight_ctx*);
- static cn_hash_fun func_selector(bool bHaveAes, bool bNoPrefetch);
+ static cn_hash_fun func_selector(bool bHaveAes, bool bNoPrefetch, bool useXMR);
static bool thd_setaffinity(std::thread::native_handle_type h, uint64_t cpu_id);
static cryptonight_ctx* minethd_alloc_ctx();
@@ -31,7 +31,7 @@ public:
private:
typedef void (*cn_hash_fun_dbl)(const void*, size_t, void*, cryptonight_ctx* __restrict, cryptonight_ctx* __restrict);
- static cn_hash_fun_dbl func_dbl_selector(bool bHaveAes, bool bNoPrefetch);
+ static cn_hash_fun_dbl func_dbl_selector(bool bHaveAes, bool bNoPrefetch, bool useXMR);
minethd(miner_work& pWork, size_t iNo, bool double_work, bool no_prefetch, int64_t affinity);