fzorb/REDACTED-rig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge xmrig v6.15.3 into master

Browse source
This commit is contained in:
MoneroOcean 2021-11-01 16:46:52 +00:00
commit 449982aad2
37 changed files with 3117 additions and 2744 deletions
Download patch file Download diff file Expand all files Collapse all files

247
src/crypto/astrobwt/AstroBWT.cpp
View file

@ -86,15 +86,54 @@ static void Salsa20_XORKeyStream_AVX256(const void* key, void* output, size_t si
}
#endif
void sort_indices(int N, const uint8_t* v, uint64_t* indices, uint64_t* tmp_indices)
static inline bool smaller(const uint8_t* v, uint64_t a, uint64_t b)
{
const uint64_t value_a = a >> 21;
const uint64_t value_b = b >> 21;
if (value_a < value_b) {
return true;
}
if (value_a > value_b) {
return false;
}
a &= (1 << 21) - 1;
b &= (1 << 21) - 1;
if (a == b) {
return false;
}
const uint64_t data_a = bswap_64(*reinterpret_cast<const uint64_t*>(v + a + 5));
const uint64_t data_b = bswap_64(*reinterpret_cast<const uint64_t*>(v + b + 5));
return (data_a < data_b);
}
void sort_indices(uint32_t N, const uint8_t* v, uint64_t* indices, uint64_t* tmp_indices)
{
uint32_t counters[2][COUNTING_SORT_SIZE] = {};
for (int i = 0; i < N; ++i)
{
const uint64_t k = bswap_64(*reinterpret_cast<const uint64_t*>(v + i));
++counters[0][(k >> (64 - COUNTING_SORT_BITS * 2)) & (COUNTING_SORT_SIZE - 1)];
++counters[1][k >> (64 - COUNTING_SORT_BITS)];
#define ITER(X) \
do { \
const uint64_t k = bswap_64(*reinterpret_cast<const uint64_t*>(v + i + X)); \
++counters[0][(k >> (64 - COUNTING_SORT_BITS * 2)) & (COUNTING_SORT_SIZE - 1)]; \
++counters[1][k >> (64 - COUNTING_SORT_BITS)]; \
} while (0)
uint32_t i = 0;
const uint32_t n = N - 15;
for (; i < n; i += 16) {
ITER(0); ITER(1); ITER(2); ITER(3); ITER(4); ITER(5); ITER(6); ITER(7);
ITER(8); ITER(9); ITER(10); ITER(11); ITER(12); ITER(13); ITER(14); ITER(15);
}
for (; i < N; ++i) {
ITER(0);
}
#undef ITER
}
uint32_t prev[2] = { counters[0][0], counters[1][0] };
@ -109,41 +148,47 @@ void sort_indices(int N, const uint8_t* v, uint64_t* indices, uint64_t* tmp_indi
prev[1] = cur[1];
}
for (int i = N - 1; i >= 0; --i)
{
const uint64_t k = bswap_64(*reinterpret_cast<const uint64_t*>(v + i));
tmp_indices[counters[0][(k >> (64 - COUNTING_SORT_BITS * 2)) & (COUNTING_SORT_SIZE - 1)]--] = (k & (static_cast<uint64_t>(-1) << 21)) | i;
}
#define ITER(X) \
do { \
const uint64_t k = bswap_64(*reinterpret_cast<const uint64_t*>(v + (i - X))); \
tmp_indices[counters[0][(k >> (64 - COUNTING_SORT_BITS * 2)) & (COUNTING_SORT_SIZE - 1)]--] = (k & (static_cast<uint64_t>(-1) << 21)) | (i - X); \
} while (0)
for (int i = N - 1; i >= 0; --i)
{
const uint64_t data = tmp_indices[i];
indices[counters[1][data >> (64 - COUNTING_SORT_BITS)]--] = data;
}
auto smaller = [v](uint64_t a, uint64_t b)
{
const uint64_t value_a = a >> 21;
const uint64_t value_b = b >> 21;
if (value_a < value_b) {
return true;
uint32_t i = N;
for (; i >= 8; i -= 8) {
ITER(1); ITER(2); ITER(3); ITER(4); ITER(5); ITER(6); ITER(7); ITER(8);
}
for (; i > 0; --i) {
ITER(1);
}
if (value_a > value_b) {
return false;
#undef ITER
}
{
#define ITER(X) \
do { \
const uint64_t data = tmp_indices[i - X]; \
indices[counters[1][data >> (64 - COUNTING_SORT_BITS)]--] = data; \
} while (0)
uint32_t i = N;
for (; i >= 8; i -= 8) {
ITER(1); ITER(2); ITER(3); ITER(4); ITER(5); ITER(6); ITER(7); ITER(8);
}
for (; i > 0; --i) {
ITER(1);
}
const uint64_t data_a = bswap_64(*reinterpret_cast<const uint64_t*>(v + (a % (1 << 21)) + 5));
const uint64_t data_b = bswap_64(*reinterpret_cast<const uint64_t*>(v + (b % (1 << 21)) + 5));
return (data_a < data_b);
};
#undef ITER
}
uint64_t prev_t = indices[0];
for (int i = 1; i < N; ++i)
for (uint32_t i = 1; i < N; ++i)
{
uint64_t t = indices[i];
if (smaller(t, prev_t))
if (smaller(v, t, prev_t))
{
const uint64_t t2 = prev_t;
int j = i - 1;
@ -157,7 +202,7 @@ void sort_indices(int N, const uint8_t* v, uint64_t* indices, uint64_t* tmp_indi
}
prev_t = indices[j];
} while (smaller(t, prev_t));
} while (smaller(v, t, prev_t));
indices[j + 1] = t;
t = t2;
}
@ -165,6 +210,144 @@ void sort_indices(int N, const uint8_t* v, uint64_t* indices, uint64_t* tmp_indi
}
}
void sort_indices2(uint32_t N, const uint8_t* v, uint64_t* indices, uint64_t* tmp_indices)
{
alignas(16) uint32_t counters[1 << COUNTING_SORT_BITS] = {};
alignas(16) uint32_t counters2[1 << COUNTING_SORT_BITS];
{
#define ITER(X) { \
const uint64_t k = bswap_64(*reinterpret_cast<const uint64_t*>(v + i + X)); \
++counters[k >> (64 - COUNTING_SORT_BITS)]; \
}
uint32_t i = 0;
const uint32_t n = (N / 32) * 32;
for (; i < n; i += 32) {
ITER(0); ITER(1); ITER(2); ITER(3); ITER(4); ITER(5); ITER(6); ITER(7);
ITER(8); ITER(9); ITER(10); ITER(11); ITER(12); ITER(13); ITER(14); ITER(15);
ITER(16); ITER(17); ITER(18); ITER(19); ITER(20); ITER(21); ITER(22); ITER(23);
ITER(24); ITER(25); ITER(26); ITER(27); ITER(28); ITER(29); ITER(30); ITER(31);
}
for (; i < N; ++i) {
ITER(0);
}
#undef ITER
}
uint32_t prev = static_cast<uint32_t>(-1);
for (uint32_t i = 0; i < (1 << COUNTING_SORT_BITS); i += 16)
{
#define ITER(X) { \
const uint32_t cur = counters[i + X] + prev; \
counters[i + X] = cur; \
counters2[i + X] = cur; \
prev = cur; \
}
ITER(0); ITER(1); ITER(2); ITER(3); ITER(4); ITER(5); ITER(6); ITER(7);
ITER(8); ITER(9); ITER(10); ITER(11); ITER(12); ITER(13); ITER(14); ITER(15);
#undef ITER
}
{
#define ITER(X) \
do { \
const uint64_t k = bswap_64(*reinterpret_cast<const uint64_t*>(v + (i - X))); \
indices[counters[k >> (64 - COUNTING_SORT_BITS)]--] = (k & (static_cast<uint64_t>(-1) << 21)) | (i - X); \
} while (0)
uint32_t i = N;
for (; i >= 8; i -= 8) {
ITER(1); ITER(2); ITER(3); ITER(4); ITER(5); ITER(6); ITER(7); ITER(8);
}
for (; i > 0; --i) {
ITER(1);
}
#undef ITER
}
uint32_t prev_i = 0;
for (uint32_t i0 = 0; i0 < (1 << COUNTING_SORT_BITS); ++i0) {
const uint32_t i = counters2[i0] + 1;
const uint32_t n = i - prev_i;
if (n > 1) {
memset(counters, 0, sizeof(uint32_t) * (1 << COUNTING_SORT_BITS));
const uint32_t n8 = (n / 8) * 8;
uint32_t j = 0;
#define ITER(X) { \
const uint64_t k = indices[prev_i + j + X]; \
++counters[(k >> (64 - COUNTING_SORT_BITS * 2)) & ((1 << COUNTING_SORT_BITS) - 1)]; \
tmp_indices[j + X] = k; \
}
for (; j < n8; j += 8) {
ITER(0); ITER(1); ITER(2); ITER(3); ITER(4); ITER(5); ITER(6); ITER(7);
}
for (; j < n; ++j) {
ITER(0);
}
#undef ITER
uint32_t prev = static_cast<uint32_t>(-1);
for (uint32_t j = 0; j < (1 << COUNTING_SORT_BITS); j += 32)
{
#define ITER(X) { \
const uint32_t cur = counters[j + X] + prev; \
counters[j + X] = cur; \
prev = cur; \
}
ITER(0); ITER(1); ITER(2); ITER(3); ITER(4); ITER(5); ITER(6); ITER(7);
ITER(8); ITER(9); ITER(10); ITER(11); ITER(12); ITER(13); ITER(14); ITER(15);
ITER(16); ITER(17); ITER(18); ITER(19); ITER(20); ITER(21); ITER(22); ITER(23);
ITER(24); ITER(25); ITER(26); ITER(27); ITER(28); ITER(29); ITER(30); ITER(31);
#undef ITER
}
#define ITER(X) { \
const uint64_t k = tmp_indices[j - X]; \
const uint32_t index = counters[(k >> (64 - COUNTING_SORT_BITS * 2)) & ((1 << COUNTING_SORT_BITS) - 1)]--; \
indices[prev_i + index] = k; \
}
for (j = n; j >= 8; j -= 8) {
ITER(1); ITER(2); ITER(3); ITER(4); ITER(5); ITER(6); ITER(7); ITER(8);
}
for (; j > 0; --j) {
ITER(1);
}
#undef ITER
uint64_t prev_t = indices[prev_i];
for (uint64_t* p = indices + prev_i + 1, *e = indices + i; p != e; ++p)
{
uint64_t t = *p;
if (smaller(v, t, prev_t))
{
const uint64_t t2 = prev_t;
uint64_t* p1 = p;
do
{
*p1 = prev_t;
--p1;
if (p1 <= indices + prev_i) {
break;
}
prev_t = *(p1 - 1);
} while (smaller(v, t, prev_t));
*p1 = t;
t = t2;
}
prev_t = t;
}
}
prev_i = i;
}
}
bool xmrig::astrobwt::astrobwt_dero(const void* input_data, uint32_t input_size, void* scratchpad, uint8_t* output_hash, int stage2_max_size, bool avx2)
{
alignas(8) uint8_t key[32];
@ -219,7 +402,7 @@ bool xmrig::astrobwt::astrobwt_dero(const void* input_data, uint32_t input_size,
Salsa20_XORKeyStream(key, stage2_output, stage2_size);
}
sort_indices(stage2_size + 1, stage2_output, indices, tmp_indices);
sort_indices2(stage2_size + 1, stage2_output, indices, tmp_indices);
{
const uint8_t* tmp = stage2_output - 1;

8
src/crypto/cn/CnHash.cpp
View file

@ -322,6 +322,14 @@ xmrig::CnHash::CnHash()
}
xmrig::CnHash::~CnHash()
{
for (auto const& x : m_map) {
delete m_map[x.first];
}
}
xmrig::cn_hash_fun xmrig::CnHash::fn(const Algorithm &algorithm, AlgoVariant av, Assembly::Id assembly)
{
assert(cnHash.m_map.count(algorithm));

1
src/crypto/cn/CnHash.h
View file

@ -59,6 +59,7 @@ public:
};
CnHash();
virtual ~CnHash();
static cn_hash_fun fn(const Algorithm &algorithm, AlgoVariant av, Assembly::Id assembly);

1
src/crypto/randomx/randomx.cpp
View file

@ -460,6 +460,7 @@ extern "C" {
}
void randomx_release_cache(randomx_cache* cache) {
delete cache->jit;
delete cache;
}