mirror of
https://github.com/JayDDee/cpuminer-opt.git
synced 2025-09-17 23:44:27 +00:00
Compare commits
5 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
720610cce5 | ||
|
|
cedcf4d070 | ||
|
|
81b50c3c71 | ||
|
|
0e1e88f53e | ||
|
|
45c77a5c81 |
@@ -65,6 +65,50 @@ If not what makes it happen or not happen?
|
||||
Change Log
|
||||
----------
|
||||
|
||||
v3.12.4.6
|
||||
|
||||
Issue #246: fixed getwork repeated new block logs with same height. New work
|
||||
for the same block is now reported as "New work" instead of New block".
|
||||
Also added a check that work is new before generating "New work" log.
|
||||
|
||||
Added target diff to getwork new block log.
|
||||
|
||||
Changed share ratio in share result log to simple fraction, no longer %.
|
||||
|
||||
Added debug log to display mininginfo, use -D.
|
||||
|
||||
v3.12.4.5
|
||||
|
||||
Issue #246: better stale share detection for getwork, and enhanced logging
|
||||
of stale shares for stratum & getwork.
|
||||
|
||||
Issue #251: fixed incorrect share difficulty and share ratio in share
|
||||
result log.
|
||||
|
||||
Changed submit log to include share diff and block height.
|
||||
|
||||
Small cosmetic changes to logs.
|
||||
|
||||
v3.12.4.4
|
||||
|
||||
Issue #246: Fixed net hashrate in getwork block log,
|
||||
removed duplicate getwork block log,
|
||||
other small tweaks to stats logs for getwork.
|
||||
|
||||
Issue #248: Fixed chronic stale shares with scrypt:1048576 (scryptn2).
|
||||
|
||||
v3.12.4.3
|
||||
|
||||
Fixed segfault in new block log for getwork.
|
||||
|
||||
Disabled silent discarding of stale work after the submit is logged.
|
||||
|
||||
v3.12.4.2
|
||||
|
||||
Issue #245: fixed getwork stale shares, solo mining with getwork now works.
|
||||
|
||||
Issue #246: implemented block and summary logs for getwork.
|
||||
|
||||
v3.12.4.1
|
||||
|
||||
Issue #245: fix scantime when mining solo with getwork.
|
||||
|
||||
@@ -380,7 +380,7 @@ static inline void PBKDF2_SHA256_128_32_8way(uint32_t *tstate,
|
||||
#endif /* HAVE_SHA256_8WAY */
|
||||
|
||||
|
||||
#if defined(USE_ASM) && defined(__x86_64__)
|
||||
//#if defined(USE_ASM) && defined(__x86_64__)
|
||||
|
||||
#define SCRYPT_MAX_WAYS 12
|
||||
#define HAVE_SCRYPT_3WAY 1
|
||||
@@ -394,113 +394,6 @@ void scrypt_core_3way(uint32_t *X, uint32_t *V, int N);
|
||||
void scrypt_core_6way(uint32_t *X, uint32_t *V, int N);
|
||||
#endif
|
||||
|
||||
#elif defined(USE_ASM) && defined(__i386__)
|
||||
|
||||
#define SCRYPT_MAX_WAYS 4
|
||||
#define scrypt_best_throughput() 1
|
||||
void scrypt_core(uint32_t *X, uint32_t *V, int N);
|
||||
|
||||
#elif defined(USE_ASM) && defined(__arm__) && defined(__APCS_32__)
|
||||
|
||||
void scrypt_core(uint32_t *X, uint32_t *V, int N);
|
||||
#if defined(__ARM_NEON__)
|
||||
#undef HAVE_SHA256_4WAY
|
||||
#define SCRYPT_MAX_WAYS 3
|
||||
#define HAVE_SCRYPT_3WAY 1
|
||||
#define scrypt_best_throughput() 3
|
||||
void scrypt_core_3way(uint32_t *X, uint32_t *V, int N);
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
static inline void xor_salsa8(uint32_t B[16], const uint32_t Bx[16])
|
||||
{
|
||||
uint32_t x00,x01,x02,x03,x04,x05,x06,x07,x08,x09,x10,x11,x12,x13,x14,x15;
|
||||
int i;
|
||||
|
||||
x00 = (B[ 0] ^= Bx[ 0]);
|
||||
x01 = (B[ 1] ^= Bx[ 1]);
|
||||
x02 = (B[ 2] ^= Bx[ 2]);
|
||||
x03 = (B[ 3] ^= Bx[ 3]);
|
||||
x04 = (B[ 4] ^= Bx[ 4]);
|
||||
x05 = (B[ 5] ^= Bx[ 5]);
|
||||
x06 = (B[ 6] ^= Bx[ 6]);
|
||||
x07 = (B[ 7] ^= Bx[ 7]);
|
||||
x08 = (B[ 8] ^= Bx[ 8]);
|
||||
x09 = (B[ 9] ^= Bx[ 9]);
|
||||
x10 = (B[10] ^= Bx[10]);
|
||||
x11 = (B[11] ^= Bx[11]);
|
||||
x12 = (B[12] ^= Bx[12]);
|
||||
x13 = (B[13] ^= Bx[13]);
|
||||
x14 = (B[14] ^= Bx[14]);
|
||||
x15 = (B[15] ^= Bx[15]);
|
||||
for (i = 0; i < 8; i += 2) {
|
||||
#define R(a, b) (((a) << (b)) | ((a) >> (32 - (b))))
|
||||
/* Operate on columns. */
|
||||
x04 ^= R(x00+x12, 7); x09 ^= R(x05+x01, 7);
|
||||
x14 ^= R(x10+x06, 7); x03 ^= R(x15+x11, 7);
|
||||
|
||||
x08 ^= R(x04+x00, 9); x13 ^= R(x09+x05, 9);
|
||||
x02 ^= R(x14+x10, 9); x07 ^= R(x03+x15, 9);
|
||||
|
||||
x12 ^= R(x08+x04,13); x01 ^= R(x13+x09,13);
|
||||
x06 ^= R(x02+x14,13); x11 ^= R(x07+x03,13);
|
||||
|
||||
x00 ^= R(x12+x08,18); x05 ^= R(x01+x13,18);
|
||||
x10 ^= R(x06+x02,18); x15 ^= R(x11+x07,18);
|
||||
|
||||
/* Operate on rows. */
|
||||
x01 ^= R(x00+x03, 7); x06 ^= R(x05+x04, 7);
|
||||
x11 ^= R(x10+x09, 7); x12 ^= R(x15+x14, 7);
|
||||
|
||||
x02 ^= R(x01+x00, 9); x07 ^= R(x06+x05, 9);
|
||||
x08 ^= R(x11+x10, 9); x13 ^= R(x12+x15, 9);
|
||||
|
||||
x03 ^= R(x02+x01,13); x04 ^= R(x07+x06,13);
|
||||
x09 ^= R(x08+x11,13); x14 ^= R(x13+x12,13);
|
||||
|
||||
x00 ^= R(x03+x02,18); x05 ^= R(x04+x07,18);
|
||||
x10 ^= R(x09+x08,18); x15 ^= R(x14+x13,18);
|
||||
#undef R
|
||||
}
|
||||
B[ 0] += x00;
|
||||
B[ 1] += x01;
|
||||
B[ 2] += x02;
|
||||
B[ 3] += x03;
|
||||
B[ 4] += x04;
|
||||
B[ 5] += x05;
|
||||
B[ 6] += x06;
|
||||
B[ 7] += x07;
|
||||
B[ 8] += x08;
|
||||
B[ 9] += x09;
|
||||
B[10] += x10;
|
||||
B[11] += x11;
|
||||
B[12] += x12;
|
||||
B[13] += x13;
|
||||
B[14] += x14;
|
||||
B[15] += x15;
|
||||
}
|
||||
|
||||
static inline void scrypt_core(uint32_t *X, uint32_t *V, int N)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < N; i++) {
|
||||
memcpy(&V[i * 32], X, 128);
|
||||
xor_salsa8(&X[0], &X[16]);
|
||||
xor_salsa8(&X[16], &X[0]);
|
||||
}
|
||||
for (i = 0; i < N; i++) {
|
||||
uint32_t j = 32 * (X[16] & (N - 1));
|
||||
for (uint8_t k = 0; k < 32; k++)
|
||||
X[k] ^= V[j + k];
|
||||
xor_salsa8(&X[0], &X[16]);
|
||||
xor_salsa8(&X[16], &X[0]);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef SCRYPT_MAX_WAYS
|
||||
#define SCRYPT_MAX_WAYS 1
|
||||
#define scrypt_best_throughput() 1
|
||||
@@ -511,8 +404,8 @@ unsigned char *scrypt_buffer_alloc(int N)
|
||||
return (uchar*) malloc((size_t)N * SCRYPT_MAX_WAYS * 128 + 63);
|
||||
}
|
||||
|
||||
static void scrypt_1024_1_1_256(const uint32_t *input, uint32_t *output,
|
||||
uint32_t *midstate, unsigned char *scratchpad, int N)
|
||||
static bool scrypt_1024_1_1_256(const uint32_t *input, uint32_t *output,
|
||||
uint32_t *midstate, unsigned char *scratchpad, int N, int thr_id )
|
||||
{
|
||||
uint32_t tstate[8], ostate[8];
|
||||
uint32_t X[32];
|
||||
@@ -527,11 +420,13 @@ static void scrypt_1024_1_1_256(const uint32_t *input, uint32_t *output,
|
||||
scrypt_core(X, V, N);
|
||||
|
||||
PBKDF2_SHA256_128_32(tstate, ostate, X, output);
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef HAVE_SHA256_4WAY
|
||||
static void scrypt_1024_1_1_256_4way(const uint32_t *input,
|
||||
uint32_t *output, uint32_t *midstate, unsigned char *scratchpad, int N)
|
||||
static bool scrypt_1024_1_1_256_4way(const uint32_t *input,
|
||||
uint32_t *output, uint32_t *midstate, unsigned char *scratchpad, int N,
|
||||
int thrid )
|
||||
{
|
||||
uint32_t _ALIGN(128) tstate[4 * 8];
|
||||
uint32_t _ALIGN(128) ostate[4 * 8];
|
||||
@@ -545,32 +440,43 @@ static void scrypt_1024_1_1_256_4way(const uint32_t *input,
|
||||
for (i = 0; i < 20; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
W[4 * i + k] = input[k * 20 + i];
|
||||
for (i = 0; i < 8; i++)
|
||||
|
||||
for (i = 0; i < 8; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
tstate[4 * i + k] = midstate[i];
|
||||
HMAC_SHA256_80_init_4way(W, tstate, ostate);
|
||||
PBKDF2_SHA256_80_128_4way(tstate, ostate, W, W);
|
||||
for (i = 0; i < 32; i++)
|
||||
|
||||
HMAC_SHA256_80_init_4way(W, tstate, ostate);
|
||||
|
||||
PBKDF2_SHA256_80_128_4way(tstate, ostate, W, W);
|
||||
|
||||
for (i = 0; i < 32; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
X[k * 32 + i] = W[4 * i + k];
|
||||
scrypt_core(X + 0 * 32, V, N);
|
||||
|
||||
scrypt_core(X + 0 * 32, V, N);
|
||||
scrypt_core(X + 1 * 32, V, N);
|
||||
scrypt_core(X + 2 * 32, V, N);
|
||||
scrypt_core(X + 3 * 32, V, N);
|
||||
for (i = 0; i < 32; i++)
|
||||
|
||||
for (i = 0; i < 32; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
W[4 * i + k] = X[k * 32 + i];
|
||||
PBKDF2_SHA256_128_32_4way(tstate, ostate, W, W);
|
||||
for (i = 0; i < 8; i++)
|
||||
|
||||
PBKDF2_SHA256_128_32_4way(tstate, ostate, W, W);
|
||||
|
||||
for (i = 0; i < 8; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
output[k * 8 + i] = W[4 * i + k];
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif /* HAVE_SHA256_4WAY */
|
||||
|
||||
#ifdef HAVE_SCRYPT_3WAY
|
||||
|
||||
static void scrypt_1024_1_1_256_3way(const uint32_t *input,
|
||||
uint32_t *output, uint32_t *midstate, unsigned char *scratchpad, int N)
|
||||
static bool scrypt_1024_1_1_256_3way(const uint32_t *input,
|
||||
uint32_t *output, uint32_t *midstate, unsigned char *scratchpad, int N,
|
||||
int thrid )
|
||||
{
|
||||
uint32_t _ALIGN(64) tstate[3 * 8], ostate[3 * 8];
|
||||
uint32_t _ALIGN(64) X[3 * 32];
|
||||
@@ -581,23 +487,34 @@ static void scrypt_1024_1_1_256_3way(const uint32_t *input,
|
||||
memcpy(tstate + 0, midstate, 32);
|
||||
memcpy(tstate + 8, midstate, 32);
|
||||
memcpy(tstate + 16, midstate, 32);
|
||||
HMAC_SHA256_80_init(input + 0, tstate + 0, ostate + 0);
|
||||
|
||||
HMAC_SHA256_80_init(input + 0, tstate + 0, ostate + 0);
|
||||
HMAC_SHA256_80_init(input + 20, tstate + 8, ostate + 8);
|
||||
HMAC_SHA256_80_init(input + 40, tstate + 16, ostate + 16);
|
||||
PBKDF2_SHA256_80_128(tstate + 0, ostate + 0, input + 0, X + 0);
|
||||
|
||||
if ( work_restart[thrid].restart ) return false;
|
||||
|
||||
PBKDF2_SHA256_80_128(tstate + 0, ostate + 0, input + 0, X + 0);
|
||||
PBKDF2_SHA256_80_128(tstate + 8, ostate + 8, input + 20, X + 32);
|
||||
PBKDF2_SHA256_80_128(tstate + 16, ostate + 16, input + 40, X + 64);
|
||||
|
||||
scrypt_core_3way(X, V, N);
|
||||
if ( work_restart[thrid].restart ) return false;
|
||||
|
||||
PBKDF2_SHA256_128_32(tstate + 0, ostate + 0, X + 0, output + 0);
|
||||
scrypt_core_3way(X, V, N);
|
||||
|
||||
if ( work_restart[thrid].restart ) return false;
|
||||
|
||||
PBKDF2_SHA256_128_32(tstate + 0, ostate + 0, X + 0, output + 0);
|
||||
PBKDF2_SHA256_128_32(tstate + 8, ostate + 8, X + 32, output + 8);
|
||||
PBKDF2_SHA256_128_32(tstate + 16, ostate + 16, X + 64, output + 16);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef HAVE_SHA256_4WAY
|
||||
static void scrypt_1024_1_1_256_12way(const uint32_t *input,
|
||||
uint32_t *output, uint32_t *midstate, unsigned char *scratchpad, int N)
|
||||
static bool scrypt_1024_1_1_256_12way(const uint32_t *input,
|
||||
uint32_t *output, uint32_t *midstate, unsigned char *scratchpad, int N,
|
||||
int thrid )
|
||||
{
|
||||
uint32_t _ALIGN(128) tstate[12 * 8];
|
||||
uint32_t _ALIGN(128) ostate[12 * 8];
|
||||
@@ -612,43 +529,60 @@ static void scrypt_1024_1_1_256_12way(const uint32_t *input,
|
||||
for (i = 0; i < 20; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
W[128 * j + 4 * i + k] = input[80 * j + k * 20 + i];
|
||||
for (j = 0; j < 3; j++)
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 8; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
tstate[32 * j + 4 * i + k] = midstate[i];
|
||||
HMAC_SHA256_80_init_4way(W + 0, tstate + 0, ostate + 0);
|
||||
|
||||
HMAC_SHA256_80_init_4way(W + 0, tstate + 0, ostate + 0);
|
||||
HMAC_SHA256_80_init_4way(W + 128, tstate + 32, ostate + 32);
|
||||
HMAC_SHA256_80_init_4way(W + 256, tstate + 64, ostate + 64);
|
||||
PBKDF2_SHA256_80_128_4way(tstate + 0, ostate + 0, W + 0, W + 0);
|
||||
|
||||
if ( work_restart[thrid].restart ) return false;
|
||||
|
||||
PBKDF2_SHA256_80_128_4way(tstate + 0, ostate + 0, W + 0, W + 0);
|
||||
PBKDF2_SHA256_80_128_4way(tstate + 32, ostate + 32, W + 128, W + 128);
|
||||
PBKDF2_SHA256_80_128_4way(tstate + 64, ostate + 64, W + 256, W + 256);
|
||||
for (j = 0; j < 3; j++)
|
||||
|
||||
if ( work_restart[thrid].restart ) return false;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 32; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
X[128 * j + k * 32 + i] = W[128 * j + 4 * i + k];
|
||||
scrypt_core_3way(X + 0 * 96, V, N);
|
||||
|
||||
scrypt_core_3way(X + 0 * 96, V, N);
|
||||
scrypt_core_3way(X + 1 * 96, V, N);
|
||||
scrypt_core_3way(X + 2 * 96, V, N);
|
||||
scrypt_core_3way(X + 3 * 96, V, N);
|
||||
for (j = 0; j < 3; j++)
|
||||
|
||||
if ( work_restart[thrid].restart ) return false;
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 32; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
W[128 * j + 4 * i + k] = X[128 * j + k * 32 + i];
|
||||
PBKDF2_SHA256_128_32_4way(tstate + 0, ostate + 0, W + 0, W + 0);
|
||||
|
||||
PBKDF2_SHA256_128_32_4way(tstate + 0, ostate + 0, W + 0, W + 0);
|
||||
PBKDF2_SHA256_128_32_4way(tstate + 32, ostate + 32, W + 128, W + 128);
|
||||
PBKDF2_SHA256_128_32_4way(tstate + 64, ostate + 64, W + 256, W + 256);
|
||||
for (j = 0; j < 3; j++)
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 8; i++)
|
||||
for (k = 0; k < 4; k++)
|
||||
output[32 * j + k * 8 + i] = W[128 * j + 4 * i + k];
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif /* HAVE_SHA256_4WAY */
|
||||
|
||||
#endif /* HAVE_SCRYPT_3WAY */
|
||||
|
||||
#ifdef HAVE_SCRYPT_6WAY
|
||||
static void scrypt_1024_1_1_256_24way(const uint32_t *input,
|
||||
uint32_t *output, uint32_t *midstate, unsigned char *scratchpad, int N)
|
||||
static bool scrypt_1024_1_1_256_24way( const uint32_t *input,
|
||||
uint32_t *output, uint32_t *midstate,
|
||||
unsigned char *scratchpad, int N, int thrid )
|
||||
{
|
||||
uint32_t _ALIGN(128) tstate[24 * 8];
|
||||
uint32_t _ALIGN(128) ostate[24 * 8];
|
||||
@@ -657,41 +591,57 @@ static void scrypt_1024_1_1_256_24way(const uint32_t *input,
|
||||
uint32_t *V;
|
||||
int i, j, k;
|
||||
|
||||
V = (uint32_t *)(((uintptr_t)(scratchpad) + 63) & ~ (uintptr_t)(63));
|
||||
V = (uint32_t *)( ( (uintptr_t)(scratchpad) + 63 ) & ~ (uintptr_t)(63) );
|
||||
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 20; i++)
|
||||
for (k = 0; k < 8; k++)
|
||||
for ( j = 0; j < 3; j++ )
|
||||
for ( i = 0; i < 20; i++ )
|
||||
for ( k = 0; k < 8; k++ )
|
||||
W[8 * 32 * j + 8 * i + k] = input[8 * 20 * j + k * 20 + i];
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 8; i++)
|
||||
for (k = 0; k < 8; k++)
|
||||
|
||||
for ( j = 0; j < 3; j++ )
|
||||
for ( i = 0; i < 8; i++ )
|
||||
for ( k = 0; k < 8; k++ )
|
||||
tstate[8 * 8 * j + 8 * i + k] = midstate[i];
|
||||
HMAC_SHA256_80_init_8way(W + 0, tstate + 0, ostate + 0);
|
||||
HMAC_SHA256_80_init_8way(W + 256, tstate + 64, ostate + 64);
|
||||
HMAC_SHA256_80_init_8way(W + 512, tstate + 128, ostate + 128);
|
||||
PBKDF2_SHA256_80_128_8way(tstate + 0, ostate + 0, W + 0, W + 0);
|
||||
PBKDF2_SHA256_80_128_8way(tstate + 64, ostate + 64, W + 256, W + 256);
|
||||
PBKDF2_SHA256_80_128_8way(tstate + 128, ostate + 128, W + 512, W + 512);
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 32; i++)
|
||||
for (k = 0; k < 8; k++)
|
||||
|
||||
HMAC_SHA256_80_init_8way( W + 0, tstate + 0, ostate + 0 );
|
||||
HMAC_SHA256_80_init_8way( W + 256, tstate + 64, ostate + 64 );
|
||||
HMAC_SHA256_80_init_8way( W + 512, tstate + 128, ostate + 128 );
|
||||
|
||||
if ( work_restart[thrid].restart ) return false;
|
||||
|
||||
PBKDF2_SHA256_80_128_8way( tstate + 0, ostate + 0, W + 0, W + 0 );
|
||||
PBKDF2_SHA256_80_128_8way( tstate + 64, ostate + 64, W + 256, W + 256 );
|
||||
PBKDF2_SHA256_80_128_8way( tstate + 128, ostate + 128, W + 512, W + 512 );
|
||||
|
||||
if ( work_restart[thrid].restart ) return false;
|
||||
|
||||
for ( j = 0; j < 3; j++ )
|
||||
for ( i = 0; i < 32; i++ )
|
||||
for ( k = 0; k < 8; k++ )
|
||||
X[8 * 32 * j + k * 32 + i] = W[8 * 32 * j + 8 * i + k];
|
||||
scrypt_core_6way(X + 0 * 32, V, N);
|
||||
scrypt_core_6way(X + 6 * 32, V, N);
|
||||
scrypt_core_6way(X + 12 * 32, V, N);
|
||||
scrypt_core_6way(X + 18 * 32, V, N);
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 32; i++)
|
||||
for (k = 0; k < 8; k++)
|
||||
|
||||
scrypt_core_6way( X + 0 * 32, V, N );
|
||||
scrypt_core_6way( X + 6 * 32, V, N );
|
||||
scrypt_core_6way( X + 12 * 32, V, N );
|
||||
scrypt_core_6way( X + 18 * 32, V, N );
|
||||
|
||||
if ( work_restart[thrid].restart ) return false;
|
||||
|
||||
for ( j = 0; j < 3; j++ )
|
||||
for ( i = 0; i < 32; i++ )
|
||||
for ( k = 0; k < 8; k++ )
|
||||
W[8 * 32 * j + 8 * i + k] = X[8 * 32 * j + k * 32 + i];
|
||||
PBKDF2_SHA256_128_32_8way(tstate + 0, ostate + 0, W + 0, W + 0);
|
||||
PBKDF2_SHA256_128_32_8way(tstate + 64, ostate + 64, W + 256, W + 256);
|
||||
PBKDF2_SHA256_128_32_8way(tstate + 128, ostate + 128, W + 512, W + 512);
|
||||
for (j = 0; j < 3; j++)
|
||||
for (i = 0; i < 8; i++)
|
||||
for (k = 0; k < 8; k++)
|
||||
|
||||
PBKDF2_SHA256_128_32_8way( tstate + 0, ostate + 0, W + 0, W + 0 );
|
||||
PBKDF2_SHA256_128_32_8way( tstate + 64, ostate + 64, W + 256, W + 256 );
|
||||
PBKDF2_SHA256_128_32_8way( tstate + 128, ostate + 128, W + 512, W + 512 );
|
||||
|
||||
for ( j = 0; j < 3; j++ )
|
||||
for ( i = 0; i < 8; i++ )
|
||||
for ( k = 0; k < 8; k++ )
|
||||
output[8 * 8 * j + k * 8 + i] = W[8 * 32 * j + 8 * i + k];
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif /* HAVE_SCRYPT_6WAY */
|
||||
|
||||
@@ -703,7 +653,6 @@ extern int scanhash_scrypt( struct work *work, uint32_t max_nonce,
|
||||
uint32_t data[SCRYPT_MAX_WAYS * 20], hash[SCRYPT_MAX_WAYS * 8];
|
||||
uint32_t midstate[8];
|
||||
uint32_t n = pdata[19] - 1;
|
||||
const uint32_t Htarg = ptarget[7];
|
||||
int thr_id = mythr->id; // thr_id arg is deprecated
|
||||
int throughput = scrypt_best_throughput();
|
||||
int i;
|
||||
@@ -714,6 +663,8 @@ extern int scanhash_scrypt( struct work *work, uint32_t max_nonce,
|
||||
throughput *= 4;
|
||||
#endif
|
||||
|
||||
// applog(LOG_INFO,"Scrypt thoughput %d",throughput);
|
||||
|
||||
for (i = 0; i < throughput; i++)
|
||||
memcpy(data + i * 20, pdata, 80);
|
||||
|
||||
@@ -721,46 +672,49 @@ extern int scanhash_scrypt( struct work *work, uint32_t max_nonce,
|
||||
sha256_transform(midstate, data, 0);
|
||||
|
||||
do {
|
||||
|
||||
bool rc = true;
|
||||
for (i = 0; i < throughput; i++)
|
||||
data[i * 20 + 19] = ++n;
|
||||
|
||||
#if defined(HAVE_SHA256_4WAY)
|
||||
if (throughput == 4)
|
||||
scrypt_1024_1_1_256_4way(data, hash, midstate,
|
||||
scratchbuf, scratchbuf_size );
|
||||
rc = scrypt_1024_1_1_256_4way(data, hash, midstate,
|
||||
scratchbuf, scratchbuf_size, thr_id );
|
||||
else
|
||||
#endif
|
||||
#if defined(HAVE_SCRYPT_3WAY) && defined(HAVE_SHA256_4WAY)
|
||||
if (throughput == 12)
|
||||
scrypt_1024_1_1_256_12way(data, hash, midstate,
|
||||
scratchbuf, scratchbuf_size );
|
||||
rc = scrypt_1024_1_1_256_12way(data, hash, midstate,
|
||||
scratchbuf, scratchbuf_size, thr_id );
|
||||
else
|
||||
#endif
|
||||
#if defined(HAVE_SCRYPT_6WAY)
|
||||
if (throughput == 24)
|
||||
scrypt_1024_1_1_256_24way(data, hash, midstate,
|
||||
scratchbuf, scratchbuf_size );
|
||||
rc = scrypt_1024_1_1_256_24way(data, hash, midstate,
|
||||
scratchbuf, scratchbuf_size, thr_id );
|
||||
else
|
||||
#endif
|
||||
#if defined(HAVE_SCRYPT_3WAY)
|
||||
if (throughput == 3)
|
||||
scrypt_1024_1_1_256_3way(data, hash, midstate,
|
||||
scratchbuf, scratchbuf_size );
|
||||
rc = scrypt_1024_1_1_256_3way(data, hash, midstate,
|
||||
scratchbuf, scratchbuf_size, thr_id );
|
||||
else
|
||||
#endif
|
||||
scrypt_1024_1_1_256(data, hash, midstate, scratchbuf,
|
||||
scratchbuf_size );
|
||||
rc = scrypt_1024_1_1_256(data, hash, midstate, scratchbuf,
|
||||
scratchbuf_size, thr_id );
|
||||
|
||||
for (i = 0; i < throughput; i++) {
|
||||
if (unlikely(hash[i * 8 + 7] <= Htarg && fulltest(hash + i * 8, ptarget))) {
|
||||
if ( rc )
|
||||
for ( i = 0; i < throughput; i++ )
|
||||
{
|
||||
if ( unlikely( valid_hash( hash + i * 8, ptarget ) ) )
|
||||
{
|
||||
pdata[19] = data[i * 20 + 19];
|
||||
submit_solution( work, hash, mythr );
|
||||
submit_lane_solution( work, hash, mythr, i );
|
||||
}
|
||||
}
|
||||
} while ( likely( n < max_nonce && !(*restart) ) );
|
||||
} while ( likely( ( n < ( max_nonce - throughput ) ) && !(*restart) ) );
|
||||
|
||||
*hashes_done = n - pdata[19] + 1;
|
||||
*hashes_done = n - pdata[19];
|
||||
pdata[19] = n;
|
||||
return 0;
|
||||
}
|
||||
@@ -779,7 +733,6 @@ bool register_scrypt_algo( algo_gate_t* gate )
|
||||
gate->optimizations = SSE2_OPT | AVX2_OPT;
|
||||
gate->miner_thread_init =(void*)&scrypt_miner_thread_init;
|
||||
gate->scanhash = (void*)&scanhash_scrypt;
|
||||
// gate->hash = (void*)&scrypt_1024_1_1_256_24way;
|
||||
opt_target_factor = 65536.0;
|
||||
|
||||
if ( !opt_param_n )
|
||||
|
||||
20
configure
vendored
20
configure
vendored
@@ -1,6 +1,6 @@
|
||||
#! /bin/sh
|
||||
# Guess values for system-dependent variables and create Makefiles.
|
||||
# Generated by GNU Autoconf 2.69 for cpuminer-opt 3.12.4.1.
|
||||
# Generated by GNU Autoconf 2.69 for cpuminer-opt 3.12.4.6.
|
||||
#
|
||||
#
|
||||
# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
|
||||
@@ -577,8 +577,8 @@ MAKEFLAGS=
|
||||
# Identity of this package.
|
||||
PACKAGE_NAME='cpuminer-opt'
|
||||
PACKAGE_TARNAME='cpuminer-opt'
|
||||
PACKAGE_VERSION='3.12.4.1'
|
||||
PACKAGE_STRING='cpuminer-opt 3.12.4.1'
|
||||
PACKAGE_VERSION='3.12.4.6'
|
||||
PACKAGE_STRING='cpuminer-opt 3.12.4.6'
|
||||
PACKAGE_BUGREPORT=''
|
||||
PACKAGE_URL=''
|
||||
|
||||
@@ -1332,7 +1332,7 @@ if test "$ac_init_help" = "long"; then
|
||||
# Omit some internal or obsolete options to make the list less imposing.
|
||||
# This message is too long to be a string in the A/UX 3.1 sh.
|
||||
cat <<_ACEOF
|
||||
\`configure' configures cpuminer-opt 3.12.4.1 to adapt to many kinds of systems.
|
||||
\`configure' configures cpuminer-opt 3.12.4.6 to adapt to many kinds of systems.
|
||||
|
||||
Usage: $0 [OPTION]... [VAR=VALUE]...
|
||||
|
||||
@@ -1404,7 +1404,7 @@ fi
|
||||
|
||||
if test -n "$ac_init_help"; then
|
||||
case $ac_init_help in
|
||||
short | recursive ) echo "Configuration of cpuminer-opt 3.12.4.1:";;
|
||||
short | recursive ) echo "Configuration of cpuminer-opt 3.12.4.6:";;
|
||||
esac
|
||||
cat <<\_ACEOF
|
||||
|
||||
@@ -1509,7 +1509,7 @@ fi
|
||||
test -n "$ac_init_help" && exit $ac_status
|
||||
if $ac_init_version; then
|
||||
cat <<\_ACEOF
|
||||
cpuminer-opt configure 3.12.4.1
|
||||
cpuminer-opt configure 3.12.4.6
|
||||
generated by GNU Autoconf 2.69
|
||||
|
||||
Copyright (C) 2012 Free Software Foundation, Inc.
|
||||
@@ -2012,7 +2012,7 @@ cat >config.log <<_ACEOF
|
||||
This file contains any messages produced by compilers while
|
||||
running configure, to aid debugging if configure makes a mistake.
|
||||
|
||||
It was created by cpuminer-opt $as_me 3.12.4.1, which was
|
||||
It was created by cpuminer-opt $as_me 3.12.4.6, which was
|
||||
generated by GNU Autoconf 2.69. Invocation command line was
|
||||
|
||||
$ $0 $@
|
||||
@@ -2993,7 +2993,7 @@ fi
|
||||
|
||||
# Define the identity of the package.
|
||||
PACKAGE='cpuminer-opt'
|
||||
VERSION='3.12.4.1'
|
||||
VERSION='3.12.4.6'
|
||||
|
||||
|
||||
cat >>confdefs.h <<_ACEOF
|
||||
@@ -6690,7 +6690,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
||||
# report actual input values of CONFIG_FILES etc. instead of their
|
||||
# values after options handling.
|
||||
ac_log="
|
||||
This file was extended by cpuminer-opt $as_me 3.12.4.1, which was
|
||||
This file was extended by cpuminer-opt $as_me 3.12.4.6, which was
|
||||
generated by GNU Autoconf 2.69. Invocation command line was
|
||||
|
||||
CONFIG_FILES = $CONFIG_FILES
|
||||
@@ -6756,7 +6756,7 @@ _ACEOF
|
||||
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
||||
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
|
||||
ac_cs_version="\\
|
||||
cpuminer-opt config.status 3.12.4.1
|
||||
cpuminer-opt config.status 3.12.4.6
|
||||
configured by $0, generated by GNU Autoconf 2.69,
|
||||
with options \\"\$ac_cs_config\\"
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
AC_INIT([cpuminer-opt], [3.12.4.1])
|
||||
AC_INIT([cpuminer-opt], [3.12.4.6])
|
||||
|
||||
AC_PREREQ([2.59c])
|
||||
AC_CANONICAL_SYSTEM
|
||||
|
||||
632
cpu-miner.c
632
cpu-miner.c
@@ -184,7 +184,23 @@ int default_api_listen = 4048;
|
||||
pthread_mutex_t applog_lock;
|
||||
pthread_mutex_t stats_lock;
|
||||
|
||||
static struct timeval session_start;
|
||||
static struct timeval five_min_start;
|
||||
static uint64_t session_first_block = 0;
|
||||
static double latency_sum = 0.;
|
||||
static uint64_t submit_sum = 0;
|
||||
static uint64_t accept_sum = 0;
|
||||
static uint64_t stale_sum = 0;
|
||||
static uint64_t reject_sum = 0;
|
||||
static double norm_diff_sum = 0.;
|
||||
static uint32_t last_block_height = 0;
|
||||
//static bool new_job = false;
|
||||
static double last_targetdiff = 0.;
|
||||
#if !(defined(__WINDOWS__) || defined(_WIN64) || defined(_WIN32))
|
||||
static uint32_t hi_temp = 0;
|
||||
#endif
|
||||
|
||||
|
||||
static char const short_options[] =
|
||||
#ifdef HAVE_SYSLOG_H
|
||||
"S"
|
||||
@@ -421,7 +437,9 @@ static bool work_decode( const json_t *val, struct work *work )
|
||||
net_diff = algo_gate.calc_network_diff( work );
|
||||
work->targetdiff = target_to_diff( work->target );
|
||||
// for api stats, on longpoll pools
|
||||
stratum_diff = work->targetdiff;
|
||||
// This needs cleanup, stratum_diff doean't apply solo mining
|
||||
// and targetdiff is redundant, same as net_diff.
|
||||
stratum_diff = last_targetdiff = work->targetdiff;
|
||||
work->sharediff = 0;
|
||||
algo_gate.decode_extra_data( work, &net_blocks );
|
||||
return true;
|
||||
@@ -431,68 +449,78 @@ static bool work_decode( const json_t *val, struct work *work )
|
||||
static const char *info_req =
|
||||
"{\"method\": \"getmininginfo\", \"params\": [], \"id\":8}\r\n";
|
||||
|
||||
static bool get_mininginfo(CURL *curl, struct work *work)
|
||||
static bool get_mininginfo( CURL *curl, struct work *work )
|
||||
{
|
||||
if (have_stratum || !allow_mininginfo)
|
||||
if ( have_stratum || !allow_mininginfo )
|
||||
return false;
|
||||
|
||||
int curl_err = 0;
|
||||
json_t *val = json_rpc_call(curl, rpc_url, rpc_userpass, info_req, &curl_err, 0);
|
||||
json_t *val = json_rpc_call( curl, rpc_url, rpc_userpass, info_req,
|
||||
&curl_err, 0 );
|
||||
|
||||
if (!val && curl_err == -1) {
|
||||
if ( !val && curl_err == -1 )
|
||||
{
|
||||
allow_mininginfo = false;
|
||||
if (opt_debug) {
|
||||
applog(LOG_DEBUG, "getmininginfo not supported");
|
||||
}
|
||||
if ( opt_debug )
|
||||
applog( LOG_DEBUG, "getmininginfo not supported" );
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
json_t *res = json_object_get(val, "result");
|
||||
// "blocks": 491493 (= current work height - 1)
|
||||
// "difficulty": 0.99607860999999998
|
||||
// "networkhashps": 56475980
|
||||
if (res)
|
||||
{
|
||||
json_t *key = json_object_get(res, "difficulty");
|
||||
if (key) {
|
||||
if (json_is_object(key))
|
||||
key = json_object_get(key, "proof-of-work");
|
||||
if (json_is_real(key))
|
||||
net_diff = json_real_value(key);
|
||||
}
|
||||
key = json_object_get(res, "networkhashps");
|
||||
if (key && json_is_integer(key)) {
|
||||
net_hashrate = (double) json_integer_value(key);
|
||||
}
|
||||
key = json_object_get(res, "blocks");
|
||||
if (key && json_is_integer(key)) {
|
||||
net_blocks = json_integer_value(key);
|
||||
}
|
||||
if (!work->height)
|
||||
{
|
||||
// complete missing data from getwork
|
||||
work->height = (uint32_t) net_blocks + 1;
|
||||
if (work->height > g_work.height)
|
||||
{
|
||||
restart_threads();
|
||||
if (!opt_quiet) {
|
||||
char netinfo[64] = { 0 };
|
||||
char srate[32] = { 0 };
|
||||
sprintf(netinfo, "diff %.2f", net_diff);
|
||||
if (net_hashrate) {
|
||||
format_hashrate(net_hashrate, srate);
|
||||
strcat(netinfo, ", net ");
|
||||
strcat(netinfo, srate);
|
||||
}
|
||||
applog(LOG_BLUE, "%s block %d, %s",
|
||||
algo_names[opt_algo], work->height, netinfo);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
json_t *res = json_object_get( val, "result" );
|
||||
// "blocks": 491493 (= current work height - 1)
|
||||
// "difficulty": 0.99607860999999998
|
||||
// "networkhashps": 56475980
|
||||
if ( res )
|
||||
{
|
||||
json_t *key = json_object_get( res, "difficulty" );
|
||||
if ( key )
|
||||
{
|
||||
if ( json_is_object( key ) )
|
||||
key = json_object_get( key, "proof-of-work" );
|
||||
if ( json_is_real( key ) )
|
||||
net_diff = json_real_value( key );
|
||||
}
|
||||
|
||||
key = json_object_get( res, "networkhashps" );
|
||||
if ( key && json_is_integer( key ) )
|
||||
net_hashrate = (double) json_integer_value( key );
|
||||
|
||||
key = json_object_get( res, "blocks" );
|
||||
if ( key && json_is_integer( key ) )
|
||||
net_blocks = json_integer_value( key );
|
||||
|
||||
if ( opt_debug )
|
||||
applog(LOG_INFO," Mining info: diff %.5g, net_hashrate %f, height %d",
|
||||
net_diff, net_hashrate, net_blocks );
|
||||
|
||||
if ( !work->height )
|
||||
{
|
||||
// complete missing data from getwork
|
||||
work->height = (uint32_t) net_blocks + 1;
|
||||
if ( work->height > g_work.height )
|
||||
{
|
||||
restart_threads();
|
||||
|
||||
/* redundant with new block log
|
||||
if ( !opt_quiet )
|
||||
{
|
||||
char netinfo[64] = { 0 };
|
||||
char srate[32] = { 0 };
|
||||
sprintf( netinfo, "diff %.2f", net_diff );
|
||||
if ( net_hashrate )
|
||||
{
|
||||
format_hashrate( net_hashrate, srate );
|
||||
strcat( netinfo, ", net " );
|
||||
strcat( netinfo, srate );
|
||||
}
|
||||
applog( LOG_BLUE, "%s block %d, %s",
|
||||
algo_names[opt_algo], work->height, netinfo );
|
||||
}
|
||||
*/
|
||||
}
|
||||
} // res
|
||||
}
|
||||
json_decref(val);
|
||||
json_decref( val );
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -866,33 +894,8 @@ static inline void sprintf_et( char *str, int seconds )
|
||||
sprintf( str, "%um%02us", min, sec );
|
||||
}
|
||||
|
||||
// Bitcoin formula for converting difficulty to an equivalent
|
||||
// number of hashes.
|
||||
//
|
||||
// https://en.bitcoin.it/wiki/Difficulty
|
||||
//
|
||||
// hash = diff * 2**32
|
||||
//
|
||||
// diff_to_hash = 2**32 = 0x100000000 = 4294967296;
|
||||
|
||||
const double diff_to_hash = 4294967296.;
|
||||
|
||||
static struct timeval session_start;
|
||||
static struct timeval five_min_start;
|
||||
static uint64_t session_first_block = 0;
|
||||
static double latency_sum = 0.;
|
||||
static uint64_t submit_sum = 0;
|
||||
static uint64_t accept_sum = 0;
|
||||
static uint64_t stale_sum = 0;
|
||||
static uint64_t reject_sum = 0;
|
||||
static double norm_diff_sum = 0.;
|
||||
static uint32_t last_block_height = 0;
|
||||
//static bool new_job = false;
|
||||
static double last_targetdiff = 0.;
|
||||
#if !(defined(__WINDOWS__) || defined(_WIN64) || defined(_WIN32))
|
||||
static uint32_t hi_temp = 0;
|
||||
#endif
|
||||
//static uint32_t stratum_errors = 0;
|
||||
const double exp32 = 4294967296.; // 2**32
|
||||
const double exp64 = 4294967296. * 4294967296.; // 2**64
|
||||
|
||||
struct share_stats_t
|
||||
{
|
||||
@@ -947,9 +950,9 @@ void report_summary_log( bool force )
|
||||
double share_time = (double)et.tv_sec + (double)et.tv_usec / 1e6;
|
||||
double ghrate = global_hashrate;
|
||||
|
||||
double shrate = share_time == 0. ? 0. : diff_to_hash * last_targetdiff
|
||||
double shrate = share_time == 0. ? 0. : exp32 * last_targetdiff
|
||||
* (double)(accepts) / share_time;
|
||||
double sess_hrate = uptime.tv_sec == 0. ? 0. : diff_to_hash * norm_diff_sum
|
||||
double sess_hrate = uptime.tv_sec == 0. ? 0. : exp32 * norm_diff_sum
|
||||
/ (double)uptime.tv_sec;
|
||||
|
||||
double submit_rate = share_time == 0. ? 0. : (double)submits*60. / share_time;
|
||||
@@ -966,7 +969,8 @@ void report_summary_log( bool force )
|
||||
sprintf_et( et_str, et.tv_sec );
|
||||
sprintf_et( upt_str, uptime.tv_sec );
|
||||
|
||||
applog( LOG_NOTICE, "Periodic Report %s %s", et_str, upt_str );
|
||||
applog( LOG_BLUE, "%s: %s", algo_names[ opt_algo ], short_url );
|
||||
applog2( LOG_NOTICE, "Periodic Report %s %s", et_str, upt_str );
|
||||
applog2( LOG_INFO, "Share rate %.2f/min %.2f/min",
|
||||
submit_rate, (double)submitted_share_count*60. /
|
||||
( (double)uptime.tv_sec + (double)uptime.tv_usec / 1e6 ) );
|
||||
@@ -977,11 +981,11 @@ void report_summary_log( bool force )
|
||||
if ( accepted_share_count < submitted_share_count )
|
||||
{
|
||||
double lost_ghrate = uptime.tv_sec == 0. ? 0.
|
||||
: diff_to_hash * last_targetdiff
|
||||
: exp32 * last_targetdiff
|
||||
* (double)(submitted_share_count - accepted_share_count )
|
||||
/ (double)uptime.tv_sec;
|
||||
double lost_shrate = share_time == 0. ? 0.
|
||||
: diff_to_hash * last_targetdiff * (double)(submits - accepts )
|
||||
: exp32 * last_targetdiff * (double)(submits - accepts )
|
||||
/ share_time;
|
||||
char lshr_units[4] = {0};
|
||||
char lghr_units[4] = {0};
|
||||
@@ -1008,7 +1012,7 @@ void report_summary_log( bool force )
|
||||
|
||||
bool lowdiff_debug = false;
|
||||
|
||||
static int share_result( int result, struct work *null_work,
|
||||
static int share_result( int result, struct work *work,
|
||||
const char *reason )
|
||||
{
|
||||
double share_time = 0., share_ratio = 0.;
|
||||
@@ -1053,31 +1057,45 @@ static int share_result( int result, struct work *null_work,
|
||||
}
|
||||
|
||||
share_ratio = my_stats.net_diff == 0. ? 0. : my_stats.share_diff /
|
||||
my_stats.net_diff * 100.;
|
||||
|
||||
my_stats.net_diff;
|
||||
// check result
|
||||
if ( likely( result ) )
|
||||
{
|
||||
accepted_share_count++;
|
||||
sprintf( sres, "S%d", stale_share_count );
|
||||
sprintf( rres, "R%d", rejected_share_count );
|
||||
if unlikely( ( my_stats.net_diff > 0. )
|
||||
&& ( my_stats.share_diff >= net_diff ) )
|
||||
{
|
||||
solved = true;
|
||||
solved_block_count++;
|
||||
sprintf( bres, "BLOCK SOLVED %d", solved_block_count );
|
||||
sprintf( ares, "A%d", accepted_share_count );
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf( bres, "B%d", solved_block_count );
|
||||
sprintf( ares, "Accepted %d", accepted_share_count );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( reason && strstr( reason, "Invalid job id" ) )
|
||||
sprintf( ares, "A%d", accepted_share_count );
|
||||
sprintf( bres, "B%d", solved_block_count );
|
||||
if ( work ) stale = work->stale;
|
||||
if ( reason ) stale = stale || strstr( reason, "Invalid job id" );
|
||||
if ( stale )
|
||||
{
|
||||
stale = true;
|
||||
stale_share_count++;
|
||||
sprintf( sres, "Stale %d", stale_share_count );
|
||||
sprintf( rres, "R%d", rejected_share_count );
|
||||
}
|
||||
else
|
||||
{
|
||||
rejected_share_count++;
|
||||
sprintf( sres, "S%d", stale_share_count );
|
||||
sprintf( rres, "Rejected %d" , rejected_share_count );
|
||||
lowdiff_debug = true;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1103,74 +1121,34 @@ static int share_result( int result, struct work *null_work,
|
||||
|
||||
pthread_mutex_unlock( &stats_lock );
|
||||
|
||||
if ( likely( result ) )
|
||||
{
|
||||
if ( unlikely( solved ) )
|
||||
{
|
||||
sprintf( bres, "BLOCK SOLVED %d", solved_block_count );
|
||||
sprintf( ares, "A%d", accepted_share_count );
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf( bres, "B%d", solved_block_count );
|
||||
sprintf( ares, "Accepted %d", accepted_share_count );
|
||||
}
|
||||
sprintf( sres, "S%d", stale_share_count );
|
||||
sprintf( rres, "R%d", rejected_share_count );
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf( ares, "A%d", accepted_share_count );
|
||||
sprintf( bres, "B%d", solved_block_count );
|
||||
if ( stale )
|
||||
{
|
||||
sprintf( sres, "Stale %d", stale_share_count );
|
||||
sprintf( rres, "R%d", rejected_share_count );
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf( sres, "S%d", stale_share_count );
|
||||
sprintf( rres, "Rejected %d" , rejected_share_count );
|
||||
}
|
||||
}
|
||||
|
||||
if ( use_colors )
|
||||
{
|
||||
bcol = acol = scol = rcol = CL_WHT;
|
||||
bcol = acol = scol = rcol = CL_N;
|
||||
if ( likely( result ) )
|
||||
{
|
||||
acol = CL_GRN;
|
||||
if ( unlikely( solved ) ) bcol = CL_MAG;
|
||||
acol = CL_WHT CL_GRN;
|
||||
if ( unlikely( solved ) ) bcol = CL_WHT CL_MAG;
|
||||
}
|
||||
else if ( stale ) scol = CL_YL2;
|
||||
else rcol = CL_RED;
|
||||
else if ( stale ) scol = CL_WHT CL_YL2;
|
||||
else rcol = CL_WHT CL_RED;
|
||||
}
|
||||
else
|
||||
bcol = acol = scol = rcol = "\0";
|
||||
|
||||
applog( LOG_NOTICE, "%d %s%s %s%s %s%s %s%s" CL_WHT ", %.3f sec (%dms)",
|
||||
applog( LOG_NOTICE, "%d %s%s %s%s %s%s %s%s" CL_N ", %.3f sec (%dms)",
|
||||
my_stats.share_count, acol, ares, scol, sres, rcol, rres, bcol,
|
||||
bres, share_time, latency );
|
||||
|
||||
// purge job id when solo, diff is good
|
||||
if ( !opt_quiet )
|
||||
{
|
||||
if ( have_stratum )
|
||||
applog2( LOG_NOTICE, "Diff %.5g (%.3g%), %sBlock %d, %sJob %s" CL_WHT,
|
||||
applog2( LOG_INFO, "Diff %.5g (%.3g), %sBlock %d" CL_N ", %sJob %s",
|
||||
my_stats.share_diff, share_ratio, bcol, stratum.block_height,
|
||||
scol, my_stats.job_id );
|
||||
else
|
||||
applog2( LOG_NOTICE, "Diff %.5g (%.3g%), %sBlock %d" CL_WHT,
|
||||
my_stats.share_diff, share_ratio, bcol, stratum.block_height,
|
||||
scol );
|
||||
}
|
||||
|
||||
/*
|
||||
if ( have_stratum && !opt_quiet )
|
||||
applog2( LOG_NOTICE, "Diff %.5g (%.3g%), %sBlock %d, %sJob %s" CL_WHT,
|
||||
my_stats.share_diff, share_ratio, bcol, stratum.block_height,
|
||||
scol, my_stats.job_id );
|
||||
*/
|
||||
applog2( LOG_INFO, "Diff %.5g (%.3g), %sBlock %d",
|
||||
my_stats.share_diff, share_ratio, bcol, stratum.block_height );
|
||||
}
|
||||
|
||||
if ( unlikely( reason && !result ) )
|
||||
{
|
||||
@@ -1203,6 +1181,9 @@ static int share_result( int result, struct work *null_work,
|
||||
return 1;
|
||||
}
|
||||
|
||||
static const char *json_submit_req =
|
||||
"{\"method\": \"mining.submit\", \"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}";
|
||||
|
||||
void std_le_build_stratum_request( char *req, struct work *work )
|
||||
{
|
||||
unsigned char *xnonce2str;
|
||||
@@ -1213,9 +1194,8 @@ void std_le_build_stratum_request( char *req, struct work *work )
|
||||
bin2hex( ntimestr, (char*)(&ntime), sizeof(uint32_t) );
|
||||
bin2hex( noncestr, (char*)(&nonce), sizeof(uint32_t) );
|
||||
xnonce2str = abin2hex( work->xnonce2, work->xnonce2_len );
|
||||
snprintf( req, JSON_BUF_LEN,
|
||||
"{\"method\": \"mining.submit\", \"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}",
|
||||
rpc_user, work->job_id, xnonce2str, ntimestr, noncestr );
|
||||
snprintf( req, JSON_BUF_LEN, json_submit_req, rpc_user, work->job_id,
|
||||
xnonce2str, ntimestr, noncestr );
|
||||
free( xnonce2str );
|
||||
}
|
||||
|
||||
@@ -1230,12 +1210,14 @@ void std_be_build_stratum_request( char *req, struct work *work )
|
||||
bin2hex( ntimestr, (char*)(&ntime), sizeof(uint32_t) );
|
||||
bin2hex( noncestr, (char*)(&nonce), sizeof(uint32_t) );
|
||||
xnonce2str = abin2hex( work->xnonce2, work->xnonce2_len );
|
||||
snprintf( req, JSON_BUF_LEN,
|
||||
"{\"method\": \"mining.submit\", \"params\": [\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}",
|
||||
rpc_user, work->job_id, xnonce2str, ntimestr, noncestr );
|
||||
snprintf( req, JSON_BUF_LEN, json_submit_req, rpc_user, work->job_id,
|
||||
xnonce2str, ntimestr, noncestr );
|
||||
free( xnonce2str );
|
||||
}
|
||||
|
||||
static const char *json_getwork_req =
|
||||
"{\"method\": \"getwork\", \"params\": [\"%s\"], \"id\":4}\r\n";
|
||||
|
||||
bool std_le_submit_getwork_result( CURL *curl, struct work *work )
|
||||
{
|
||||
char req[JSON_BUF_LEN];
|
||||
@@ -1252,8 +1234,7 @@ bool std_le_submit_getwork_result( CURL *curl, struct work *work )
|
||||
return false;
|
||||
}
|
||||
// build JSON-RPC request
|
||||
snprintf( req, JSON_BUF_LEN,
|
||||
"{\"method\": \"getwork\", \"params\": [\"%s\"], \"id\":4}\r\n", gw_str );
|
||||
snprintf( req, JSON_BUF_LEN, json_getwork_req, gw_str );
|
||||
free( gw_str );
|
||||
// issue JSON-RPC request
|
||||
val = json_rpc_call( curl, rpc_url, rpc_userpass, req, NULL, 0 );
|
||||
@@ -1286,8 +1267,7 @@ bool std_be_submit_getwork_result( CURL *curl, struct work *work )
|
||||
return false;
|
||||
}
|
||||
// build JSON-RPC request
|
||||
snprintf( req, JSON_BUF_LEN,
|
||||
"{\"method\": \"getwork\", \"params\": [\"%s\"], \"id\":4}\r\n", gw_str );
|
||||
snprintf( req, JSON_BUF_LEN, json_getwork_req, gw_str );
|
||||
free( gw_str );
|
||||
// issue JSON-RPC request
|
||||
val = json_rpc_call( curl, rpc_url, rpc_userpass, req, NULL, 0 );
|
||||
@@ -1342,26 +1322,30 @@ char* std_malloc_txs_request( struct work *work )
|
||||
|
||||
static bool submit_upstream_work( CURL *curl, struct work *work )
|
||||
{
|
||||
/* pass if the previous hash is not the current previous hash */
|
||||
if ( !submit_old && memcmp( &work->data[1], &g_work.data[1], 32 ) )
|
||||
{
|
||||
if (opt_debug)
|
||||
applog(LOG_DEBUG, "DEBUG: stale work detected, discarding");
|
||||
return true;
|
||||
}
|
||||
|
||||
work->stale = false;
|
||||
// Submit anyway, discardring here messes up the stats
|
||||
if ( !have_stratum && allow_mininginfo )
|
||||
{
|
||||
struct work wheight;
|
||||
get_mininginfo( curl, &wheight );
|
||||
if ( work->height && work->height <= net_blocks )
|
||||
struct work mining_info;
|
||||
get_mininginfo( curl, &mining_info );
|
||||
if ( work->height < mining_info.height )
|
||||
{
|
||||
if (opt_debug)
|
||||
applog(LOG_WARNING, "block %u was already solved", work->height);
|
||||
return true;
|
||||
if ( !opt_quiet )
|
||||
applog( LOG_WARNING, "Block %u already solved, current block %d",
|
||||
work->height, mining_info.height );
|
||||
work->stale = true;
|
||||
}
|
||||
}
|
||||
|
||||
/* pass if the previous hash is not the current previous hash */
|
||||
if ( !( work->stale || submit_old )
|
||||
&& memcmp( &work->data[1], &g_work.data[1], 32 ) )
|
||||
{
|
||||
if ( !opt_quiet )
|
||||
applog( LOG_WARNING, "Stale work detected, submitting anyway" );
|
||||
work->stale = true;
|
||||
}
|
||||
|
||||
if ( have_stratum )
|
||||
{
|
||||
char req[JSON_BUF_LEN];
|
||||
@@ -1482,16 +1466,78 @@ start:
|
||||
else
|
||||
rc = work_decode( json_object_get( val, "result" ), work );
|
||||
|
||||
if ( opt_protocol && rc )
|
||||
if ( rc )
|
||||
{
|
||||
timeval_subtract( &diff, &tv_end, &tv_start );
|
||||
applog( LOG_DEBUG, "got new work in %.2f ms",
|
||||
if ( opt_protocol )
|
||||
{
|
||||
timeval_subtract( &diff, &tv_end, &tv_start );
|
||||
applog( LOG_DEBUG, "got new work in %.2f ms",
|
||||
( 1000.0 * diff.tv_sec ) + ( 0.001 * diff.tv_usec ) );
|
||||
}
|
||||
}
|
||||
|
||||
json_decref( val );
|
||||
// store work height in solo
|
||||
get_mininginfo(curl, work);
|
||||
|
||||
if ( work->height > last_block_height )
|
||||
{
|
||||
last_block_height = work->height;
|
||||
applog( LOG_BLUE, "New block %d, net diff %.5g, target diff %.5g",
|
||||
work->height, net_diff, work->targetdiff );
|
||||
|
||||
if ( !opt_quiet && net_diff && net_hashrate )
|
||||
{
|
||||
double miner_hr = 0.;
|
||||
pthread_mutex_lock( &stats_lock );
|
||||
|
||||
for ( int i = 0; i < opt_n_threads; i++ )
|
||||
miner_hr += thr_hashrates[i];
|
||||
global_hashrate = miner_hr;
|
||||
|
||||
pthread_mutex_unlock( &stats_lock );
|
||||
|
||||
if ( miner_hr )
|
||||
{
|
||||
double net_hr = net_hashrate;
|
||||
char net_hr_units[4] = {0};
|
||||
char miner_hr_units[4] = {0};
|
||||
char net_ttf[32];
|
||||
char miner_ttf[32];
|
||||
|
||||
sprintf_et( net_ttf, ( work->targetdiff * exp32 ) / net_hr );
|
||||
sprintf_et( miner_ttf, ( work->targetdiff * exp32 ) / miner_hr );
|
||||
scale_hash_for_display ( &miner_hr, miner_hr_units );
|
||||
scale_hash_for_display ( &net_hr, net_hr_units );
|
||||
applog2( LOG_INFO,
|
||||
"Miner TTF @ %.2f %sh/s %s, net TTF @ %.2f %sh/s %s",
|
||||
miner_hr, miner_hr_units, miner_ttf,
|
||||
net_hr, net_hr_units, net_ttf );
|
||||
}
|
||||
}
|
||||
} // work->height > last_block_height
|
||||
else if ( memcmp( &work->data[1], &g_work.data[1], 32 ) )
|
||||
{
|
||||
applog( LOG_BLUE, "New work" );
|
||||
if ( opt_debug )
|
||||
{
|
||||
uint32_t *old = g_work.data;
|
||||
uint32_t *new = work->data;
|
||||
printf("old: %08x %08x %08x %08x %08x %08x %08x %08x/n",
|
||||
old[0],old[1],old[2],old[3],old[4],old[5],old[6],old[7]);
|
||||
printf(" %08x %08x %08x %08x %08x %08x %08x %08x/n",
|
||||
old[8],old[9],old[10],old[11],old[12],old[13],old[14],old[15]);
|
||||
printf(" %08x %08x %08x %08x/n",
|
||||
old[16],old[17],old[18],old[19]);
|
||||
printf("new: %08x %08x %08x %08x %08x %08x %08x %08x/n",
|
||||
new[0],new[1],new[2],new[3],new[4],new[5],new[6],new[7]);
|
||||
printf(" %08x %08x %08x %08x %08x %08x %08x %08x/n",
|
||||
new[8],new[9],new[10],new[11],new[12],new[13],new[14],new[15]);
|
||||
printf(" %08x %08x %08x %08x/n",
|
||||
new[16],new[17],new[18],new[19]);
|
||||
}
|
||||
}
|
||||
} // rc
|
||||
|
||||
json_decref( val );
|
||||
// store work height in solo
|
||||
get_mininginfo(curl, work);
|
||||
return rc;
|
||||
}
|
||||
|
||||
@@ -1513,35 +1559,37 @@ static void workio_cmd_free(struct workio_cmd *wc)
|
||||
free(wc);
|
||||
}
|
||||
|
||||
static bool workio_get_work(struct workio_cmd *wc, CURL *curl)
|
||||
static bool workio_get_work( struct workio_cmd *wc, CURL *curl )
|
||||
{
|
||||
struct work *ret_work;
|
||||
int failures = 0;
|
||||
|
||||
ret_work = (struct work*) calloc(1, sizeof(*ret_work));
|
||||
if (!ret_work)
|
||||
ret_work = (struct work*) calloc( 1, sizeof(*ret_work) );
|
||||
if ( !ret_work )
|
||||
return false;
|
||||
|
||||
/* obtain new work from bitcoin via JSON-RPC */
|
||||
while (!get_upstream_work(curl, ret_work))
|
||||
while ( !get_upstream_work( curl, ret_work ) )
|
||||
{
|
||||
if (unlikely((opt_retries >= 0) && (++failures > opt_retries)))
|
||||
{
|
||||
applog(LOG_ERR, "json_rpc_call failed, terminating workio thread");
|
||||
free(ret_work);
|
||||
return false;
|
||||
}
|
||||
if ( unlikely( ( opt_retries >= 0 ) && ( ++failures > opt_retries ) ) )
|
||||
{
|
||||
applog( LOG_ERR, "json_rpc_call failed, terminating workio thread" );
|
||||
free( ret_work );
|
||||
return false;
|
||||
}
|
||||
|
||||
/* pause, then restart work-request loop */
|
||||
applog(LOG_ERR, "json_rpc_call failed, retry after %d seconds",
|
||||
opt_fail_pause);
|
||||
sleep(opt_fail_pause);
|
||||
/* pause, then restart work-request loop */
|
||||
applog( LOG_ERR, "json_rpc_call failed, retry after %d seconds",
|
||||
opt_fail_pause );
|
||||
sleep( opt_fail_pause );
|
||||
}
|
||||
|
||||
/* send work to requesting thread */
|
||||
if (!tq_push(wc->thr->q, ret_work))
|
||||
free(ret_work);
|
||||
if ( !tq_push(wc->thr->q, ret_work ) )
|
||||
free( ret_work );
|
||||
|
||||
report_summary_log( false );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1654,8 +1702,7 @@ static bool get_work(struct thr_info *thr, struct work *work)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool submit_work( struct thr_info *thr,
|
||||
const struct work *work_in )
|
||||
bool submit_work( struct thr_info *thr, const struct work *work_in )
|
||||
{
|
||||
struct workio_cmd *wc;
|
||||
|
||||
@@ -1679,27 +1726,47 @@ err_out:
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
// __float128?
|
||||
// Convert little endian 256 bit (38 decimal digits) unsigned integer to
|
||||
// double precision floating point with 15 decimal digits precision.
|
||||
// returns u * ( 2**256 )
|
||||
static inline double u256_to_double( const uint64_t *u )
|
||||
{
|
||||
const double exp64 = 4294967296.0 * 4294967296.0; // 2**64
|
||||
return ( ( u[3] * exp64 + u[2] ) * exp64 + u[1] ) * exp64 + u[0];
|
||||
}
|
||||
*/
|
||||
|
||||
static void update_submit_stats( struct work *work, const void *hash )
|
||||
{
|
||||
// Workaround until problems with target_to_diff are resolved.
|
||||
work->sharediff = work->targetdiff * (double)( ((uint64_t*)hash)[3] )
|
||||
/ (double)( ((uint64_t*)work->target)[3] );
|
||||
// work->sharediff = likely( hash ) ? target_to_diff( (uint32_t*)hash ) : 0.;
|
||||
|
||||
pthread_mutex_lock( &stats_lock );
|
||||
|
||||
submitted_share_count++;
|
||||
share_stats[ s_put_ptr ].share_count = submitted_share_count;
|
||||
gettimeofday( &share_stats[ s_put_ptr ].submit_time, NULL );
|
||||
share_stats[ s_put_ptr ].share_diff = work->sharediff;
|
||||
share_stats[ s_put_ptr ].net_diff = net_diff;
|
||||
share_stats[ s_put_ptr ].stratum_diff = stratum_diff;
|
||||
share_stats[ s_put_ptr ].target_diff = work->targetdiff;
|
||||
if ( have_stratum )
|
||||
strncpy( share_stats[ s_put_ptr ].job_id, work->job_id, 30 );
|
||||
s_put_ptr = stats_ptr_incr( s_put_ptr );
|
||||
|
||||
pthread_mutex_unlock( &stats_lock );
|
||||
}
|
||||
|
||||
//deprecated
|
||||
void work_set_target_ratio( struct work* work, const void *hash )
|
||||
{
|
||||
if ( likely( hash ) )
|
||||
{
|
||||
double dhash = u256_to_double( (const uint64_t*)hash );
|
||||
if ( likely( dhash > 0. ) )
|
||||
work->sharediff = work->targetdiff *
|
||||
u256_to_double( (const uint64_t*)( work->target ) ) / dhash;
|
||||
}
|
||||
else
|
||||
work->sharediff = 0.;
|
||||
submitted_share_count++;
|
||||
work->sharediff = work->targetdiff * (double)( ((uint64_t*)hash)[3] )
|
||||
/ (double)( ((uint64_t*)work->target)[3] );
|
||||
// work->sharediff = likely( hash ) ? target_to_diff( (uint32_t*)hash ) : 0.;
|
||||
|
||||
// collect some share stats
|
||||
// Frequent share submission combined with high latency can caused
|
||||
@@ -1713,12 +1780,8 @@ void work_set_target_ratio( struct work* work, const void *hash )
|
||||
share_stats[ s_put_ptr ].net_diff = net_diff;
|
||||
share_stats[ s_put_ptr ].stratum_diff = stratum_diff;
|
||||
share_stats[ s_put_ptr ].target_diff = work->targetdiff;
|
||||
|
||||
|
||||
//purge job id when solo
|
||||
if ( have_stratum )
|
||||
strncpy( share_stats[ s_put_ptr ].job_id, work->job_id, 30 );
|
||||
|
||||
s_put_ptr = stats_ptr_incr( s_put_ptr );
|
||||
|
||||
pthread_mutex_unlock( &stats_lock );
|
||||
@@ -1729,71 +1792,112 @@ bool submit_solution( struct work *work, const void *hash,
|
||||
{
|
||||
if ( likely( submit_work( thr, work ) ) )
|
||||
{
|
||||
submitted_share_count++;
|
||||
work_set_target_ratio( work, hash );
|
||||
//purge job id when solo
|
||||
update_submit_stats( work, hash );
|
||||
|
||||
if ( !opt_quiet )
|
||||
{
|
||||
if ( have_stratum )
|
||||
applog( LOG_NOTICE, "%d submitted by thread %d, job %s",
|
||||
submitted_share_count, thr->id, work->job_id );
|
||||
else
|
||||
applog( LOG_NOTICE, "%d submitted by thread %d",
|
||||
submitted_share_count, thr->id );
|
||||
if ( have_stratum )
|
||||
applog( LOG_NOTICE, "%d Submit diff %.5g, block %d, job %s",
|
||||
submitted_share_count, work->sharediff, work->height,
|
||||
work->job_id );
|
||||
else
|
||||
applog( LOG_NOTICE, "%d Submit diff %.5g, block %d",
|
||||
submitted_share_count, work->sharediff, work->height );
|
||||
}
|
||||
|
||||
if ( lowdiff_debug )
|
||||
{
|
||||
uint32_t* h = (uint32_t*)hash;
|
||||
uint32_t* t = (uint32_t*)work->target;
|
||||
applog(LOG_INFO,"Hash[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
h[7],h[6],h[5],h[4],h[3],h[2],h[1],h[0]);
|
||||
applog(LOG_INFO,"Targ[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
t[7],t[6],t[5],t[4],t[3],t[2],t[1],t[0]);
|
||||
}
|
||||
return true;
|
||||
if ( unlikely( lowdiff_debug ) )
|
||||
{
|
||||
uint32_t* h = (uint32_t*)hash;
|
||||
uint32_t* t = (uint32_t*)work->target;
|
||||
applog(LOG_INFO,"Hash[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
h[7],h[6],h[5],h[4],h[3],h[2],h[1],h[0]);
|
||||
applog(LOG_INFO,"Targ[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
t[7],t[6],t[5],t[4],t[3],t[2],t[1],t[0]);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else
|
||||
applog( LOG_WARNING, "%d failed to submit share.",
|
||||
submitted_share_count );
|
||||
applog( LOG_WARNING, "%d failed to submit share", submitted_share_count );
|
||||
return false;
|
||||
}
|
||||
|
||||
// deprecated, use submit_solution
|
||||
bool submit_lane_solution( struct work *work, const void *hash,
|
||||
struct thr_info *thr, const int lane )
|
||||
{
|
||||
if ( likely( submit_work( thr, work ) ) )
|
||||
{
|
||||
submitted_share_count++;
|
||||
work_set_target_ratio( work, hash );
|
||||
//purge job id when solo
|
||||
update_submit_stats( work, hash );
|
||||
|
||||
if ( !opt_quiet )
|
||||
{
|
||||
if ( have_stratum )
|
||||
applog( LOG_NOTICE, "%d submitted by thread %d, lane %d, job %s",
|
||||
submitted_share_count, thr->id, lane, work->job_id );
|
||||
else
|
||||
applog( LOG_NOTICE, "%d submitted by thread %d, lane %d",
|
||||
submitted_share_count, thr->id, lane );
|
||||
if ( have_stratum )
|
||||
applog( LOG_NOTICE, "%d Submit diff %.5g, block %d, job %s",
|
||||
submitted_share_count, work->sharediff, work->height,
|
||||
work->job_id );
|
||||
else
|
||||
applog( LOG_NOTICE, "%d Submit diff %.5g, block %d",
|
||||
submitted_share_count, work->sharediff, work->height );
|
||||
}
|
||||
|
||||
if ( lowdiff_debug )
|
||||
{
|
||||
uint32_t* h = (uint32_t*)hash;
|
||||
uint32_t* t = (uint32_t*)work->target;
|
||||
applog(LOG_INFO,"Hash[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
h[7],h[6],h[5],h[4],h[3],h[2],h[1],h[0]);
|
||||
applog(LOG_INFO,"Targ[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
t[7],t[6],t[5],t[4],t[3],t[2],t[1],t[0]);
|
||||
if ( lowdiff_debug )
|
||||
{
|
||||
uint32_t* h = (uint32_t*)hash;
|
||||
uint32_t* t = (uint32_t*)work->target;
|
||||
applog(LOG_INFO,"Hash[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
h[7],h[6],h[5],h[4],h[3],h[2],h[1],h[0]);
|
||||
applog(LOG_INFO,"Targ[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
t[7],t[6],t[5],t[4],t[3],t[2],t[1],t[0]);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else
|
||||
applog( LOG_WARNING, "%d failed to submit share", submitted_share_count );
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
else
|
||||
applog( LOG_WARNING, "%d failed to submit share.",
|
||||
submitted_share_count );
|
||||
return false;
|
||||
// The new way, replaces fulltest and submit_solution
|
||||
bool test_hash_and_submit( struct work *work, const void *hash,
|
||||
struct thr_info *thr )
|
||||
{
|
||||
work->sharediff = work->targetdiff * (double)( ((uint64_t*)hash)[3] )
|
||||
/ (double)( ((uint64_t*)work->target)[3] );
|
||||
|
||||
if ( work->sharediff >= work->targetdiff )
|
||||
{
|
||||
if ( likely( submit_work( thr, work ) ) )
|
||||
{
|
||||
update_submit_stats( work, hash );
|
||||
|
||||
if ( !opt_quiet )
|
||||
{
|
||||
if ( have_stratum )
|
||||
applog( LOG_NOTICE, "%d Submit diff %.5g, block %d, job %s",
|
||||
submitted_share_count, work->sharediff, work->height,
|
||||
work->job_id );
|
||||
else
|
||||
applog( LOG_NOTICE, "%d Submit diff %.5g, block %d",
|
||||
submitted_share_count, work->sharediff, work->height );
|
||||
}
|
||||
|
||||
if ( lowdiff_debug )
|
||||
{
|
||||
uint32_t* h = (uint32_t*)hash;
|
||||
uint32_t* t = (uint32_t*)work->target;
|
||||
applog(LOG_INFO,"Hash[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
h[7],h[6],h[5],h[4],h[3],h[2],h[1],h[0]);
|
||||
applog(LOG_INFO,"Targ[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
|
||||
t[7],t[6],t[5],t[4],t[3],t[2],t[1],t[0]);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else
|
||||
applog( LOG_WARNING, "%d failed to submit share, thread %d",
|
||||
submitted_share_count, thr->id );
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool wanna_mine(int thr_id)
|
||||
@@ -1886,17 +1990,15 @@ void std_get_new_work( struct work* work, struct work* g_work, int thr_id,
|
||||
uint32_t *end_nonce_ptr )
|
||||
{
|
||||
uint32_t *nonceptr = work->data + algo_gate.nonce_index;
|
||||
bool force_new_work = false;
|
||||
|
||||
//purge job id when solo
|
||||
bool force_new_work;
|
||||
if ( have_stratum )
|
||||
force_new_work = work->job_id ? strtoul( work->job_id, NULL, 16 )
|
||||
!= strtoul( g_work->job_id, NULL, 16 )
|
||||
: true;
|
||||
else
|
||||
force_new_work = false;
|
||||
: false;
|
||||
|
||||
if ( force_new_work || *nonceptr >= *end_nonce_ptr )
|
||||
if ( force_new_work || ( *nonceptr >= *end_nonce_ptr )
|
||||
|| memcmp( work->data, g_work->data, algo_gate.work_cmp_size ) )
|
||||
{
|
||||
work_free( work );
|
||||
work_copy( work, g_work );
|
||||
@@ -2205,7 +2307,7 @@ static void *miner_thread( void *userdata )
|
||||
}
|
||||
else
|
||||
sprintf( tempstr, "%d C", temp );
|
||||
applog( LOG_INFO,"CPU temp: curr %s (max %d), Freq: %.3f/%.3f GHz",
|
||||
applog( LOG_NOTICE,"CPU temp: curr %s (max %d), Freq: %.3f/%.3f GHz",
|
||||
tempstr, hi_temp, (float)lo_freq / 1e6, (float)hi_freq/ 1e6 );
|
||||
if ( temp > hi_temp ) hi_temp = temp;
|
||||
}
|
||||
@@ -2266,6 +2368,8 @@ void restart_threads(void)
|
||||
{
|
||||
for ( int i = 0; i < opt_n_threads; i++)
|
||||
work_restart[i].restart = 1;
|
||||
if ( opt_debug )
|
||||
applog( LOG_INFO, "Threads restarted for new work.");
|
||||
}
|
||||
|
||||
json_t *std_longpoll_rpc_call( CURL *curl, int *err, char* lp_url )
|
||||
@@ -2521,8 +2625,12 @@ void std_stratum_gen_work( struct stratum_ctx *sctx, struct work *g_work )
|
||||
algo_gate.build_extraheader( g_work, sctx );
|
||||
net_diff = algo_gate.calc_network_diff( g_work );
|
||||
algo_gate.set_work_data_endian( g_work );
|
||||
work_set_target( g_work, sctx->job.diff
|
||||
/ ( opt_target_factor * opt_diff_factor ) );
|
||||
g_work->height = sctx->block_height;
|
||||
g_work->targetdiff = sctx->job.diff
|
||||
/ ( opt_target_factor * opt_diff_factor );
|
||||
diff_to_target( g_work->target, g_work->targetdiff );
|
||||
// work_set_target( g_work, sctx->job.diff
|
||||
// / ( opt_target_factor * opt_diff_factor ) );
|
||||
|
||||
pthread_mutex_unlock( &sctx->work_lock );
|
||||
|
||||
@@ -2568,7 +2676,6 @@ void std_stratum_gen_work( struct stratum_ctx *sctx, struct work *g_work )
|
||||
|
||||
if ( !opt_quiet )
|
||||
{
|
||||
applog2( LOG_INFO, "%s: %s", algo_names[opt_algo], short_url );
|
||||
applog2( LOG_INFO, "Diff: Net %.5g, Stratum %.5g, Target %.5g",
|
||||
net_diff, stratum_diff, last_targetdiff );
|
||||
|
||||
@@ -2578,8 +2685,8 @@ void std_stratum_gen_work( struct stratum_ctx *sctx, struct work *g_work )
|
||||
char block_ttf[32];
|
||||
char share_ttf[32];
|
||||
|
||||
sprintf_et( block_ttf, net_diff * diff_to_hash / hr );
|
||||
sprintf_et( share_ttf, last_targetdiff * diff_to_hash / hr );
|
||||
sprintf_et( block_ttf, ( net_diff * exp32 ) / hr );
|
||||
sprintf_et( share_ttf, last_targetdiff * exp32 / hr );
|
||||
scale_hash_for_display ( &hr, hr_units );
|
||||
applog2( LOG_INFO, "TTF @ %.2f %sh/s: block %s, share %s",
|
||||
hr, hr_units, block_ttf, share_ttf );
|
||||
@@ -2594,7 +2701,7 @@ void std_stratum_gen_work( struct stratum_ctx *sctx, struct work *g_work )
|
||||
: et.tv_sec / ( last_block_height - session_first_block );
|
||||
if ( net_diff && net_ttf )
|
||||
{
|
||||
double net_hr = net_diff * diff_to_hash / net_ttf;
|
||||
double net_hr = net_diff * exp32 / net_ttf;
|
||||
char net_ttf_str[32];
|
||||
char net_hr_units[4] = {0};
|
||||
|
||||
@@ -3656,9 +3763,6 @@ int main(int argc, char *argv[])
|
||||
*/
|
||||
}
|
||||
|
||||
applog( LOG_INFO, "Extranonce subscribe: %s",
|
||||
opt_extranonce ? "YES" : "NO" );
|
||||
|
||||
#ifdef HAVE_SYSLOG_H
|
||||
if (use_syslog)
|
||||
openlog("cpuminer", LOG_PID, LOG_USER);
|
||||
|
||||
23
miner.h
23
miner.h
@@ -312,6 +312,19 @@ int varint_encode( unsigned char *p, uint64_t n );
|
||||
size_t address_to_script( unsigned char *out, size_t outsz, const char *addr );
|
||||
int timeval_subtract( struct timeval *result, struct timeval *x,
|
||||
struct timeval *y);
|
||||
|
||||
// Bitcoin formula for converting difficulty to an equivalent
|
||||
// number of hashes.
|
||||
//
|
||||
// https://en.bitcoin.it/wiki/Difficulty
|
||||
//
|
||||
// hash = diff * 2**32
|
||||
//
|
||||
// diff_to_hash = 2**32 = 0x100000000 = 4294967296 = exp32;
|
||||
|
||||
const double exp32; // 2**32
|
||||
const double exp64; // 2**64
|
||||
|
||||
bool fulltest( const uint32_t *hash, const uint32_t *target );
|
||||
bool valid_hash( const void*, const void* );
|
||||
|
||||
@@ -332,11 +345,12 @@ struct thr_info {
|
||||
|
||||
//struct thr_info *thr_info;
|
||||
|
||||
bool submit_solution( struct work *work, const void *hash,
|
||||
struct thr_info *thr );
|
||||
bool submit_lane_solution( struct work *work, const void *hash,
|
||||
struct thr_info *thr, const int lane );
|
||||
bool submit_solution( struct work *work, const void *hash,
|
||||
struct thr_info *thr );
|
||||
bool submit_lane_solution( struct work *work, const void *hash,
|
||||
struct thr_info *thr, const int lane );
|
||||
|
||||
bool test_hash_and_submit( struct work*, const void*, struct thr_info* );
|
||||
|
||||
bool submit_work( struct thr_info *thr, const struct work *work_in );
|
||||
|
||||
@@ -378,6 +392,7 @@ struct work {
|
||||
size_t xnonce2_len;
|
||||
unsigned char *xnonce2;
|
||||
bool sapling;
|
||||
bool stale;
|
||||
|
||||
// x16rt
|
||||
uint32_t merkleroothash[8];
|
||||
|
||||
85
util.c
85
util.c
@@ -983,6 +983,7 @@ int timeval_subtract(struct timeval *result, struct timeval *x,
|
||||
return x->tv_sec < y->tv_sec;
|
||||
}
|
||||
|
||||
// deprecated, use test_hash_and_submit
|
||||
// Use this when deinterleaved
|
||||
// do 64 bit test 4 iterations
|
||||
inline bool valid_hash( const void *hash, const void *target )
|
||||
@@ -999,6 +1000,7 @@ inline bool valid_hash( const void *hash, const void *target )
|
||||
return true;
|
||||
}
|
||||
|
||||
// deprecated, use test_hash_and_submit
|
||||
bool fulltest( const uint32_t *hash, const uint32_t *target )
|
||||
{
|
||||
int i;
|
||||
@@ -1039,37 +1041,55 @@ bool fulltest( const uint32_t *hash, const uint32_t *target )
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
void diff_to_target(uint32_t *target, double diff)
|
||||
{
|
||||
uint64_t m;
|
||||
uint64_t m;
|
||||
int k;
|
||||
|
||||
for (k = 6; k > 0 && diff > 1.0; k--)
|
||||
diff /= 4294967296.0;
|
||||
|
||||
m = (uint64_t)(4294901760.0 / diff);
|
||||
|
||||
if (m == 0 && k == 6)
|
||||
memset(target, 0xff, 32);
|
||||
else {
|
||||
memset(target, 0, 32);
|
||||
target[k] = (uint32_t)m;
|
||||
target[k + 1] = (uint32_t)(m >> 32);
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
void diff_to_target(uint32_t *target, double diff)
|
||||
{
|
||||
uint64_t *t = (uint64_t*)target;
|
||||
uint64_t m;
|
||||
int k;
|
||||
|
||||
const double exp64 = (double)0xffffffffffffffff + 1.;
|
||||
for ( k = 3; k > 0 && diff > 1.0; k-- )
|
||||
diff /= exp64;
|
||||
|
||||
// for (k = 6; k > 0 && diff > 1.0; k--)
|
||||
// diff /= 4294967296.0;
|
||||
m = (uint64_t)( 0xffff0000 / diff );
|
||||
if unlikely( m == 0 && k == 3 )
|
||||
memset( target, 0xff, 32 );
|
||||
m = (uint64_t)( 0xffff0000 / diff );
|
||||
|
||||
if unlikely( m == 0 && k == 3 )
|
||||
memset( t, 0xff, 32 );
|
||||
else
|
||||
{
|
||||
memset( target, 0, 32 );
|
||||
((uint64_t*)target)[k] = m;
|
||||
// target[k] = (uint32_t)m;
|
||||
// target[k + 1] = (uint32_t)(m >> 32);
|
||||
memset( t, 0, 32 );
|
||||
t[k] = m;
|
||||
}
|
||||
}
|
||||
|
||||
// Only used by stratum pools
|
||||
// deprecated
|
||||
void work_set_target(struct work* work, double diff)
|
||||
{
|
||||
diff_to_target( work->target, diff );
|
||||
work->targetdiff = diff;
|
||||
}
|
||||
|
||||
// Only used by longpoll pools
|
||||
double target_to_diff(uint32_t* target)
|
||||
{
|
||||
uchar* tgt = (uchar*) target;
|
||||
@@ -1546,35 +1566,44 @@ bool stratum_authorize(struct stratum_ctx *sctx, const char *user, const char *p
|
||||
|
||||
ret = true;
|
||||
|
||||
if (!opt_extranonce)
|
||||
if ( !opt_extranonce )
|
||||
goto out;
|
||||
|
||||
// subscribe to extranonce (optional)
|
||||
sprintf(s, "{\"id\": 3, \"method\": \"mining.extranonce.subscribe\", \"params\": []}");
|
||||
|
||||
if (!stratum_send_line(sctx, s))
|
||||
if ( !stratum_send_line( sctx, s ) )
|
||||
goto out;
|
||||
|
||||
if (!socket_full(sctx->sock, 3)) {
|
||||
applog(LOG_WARNING, "stratum extranonce subscribe timed out");
|
||||
goto out;
|
||||
if ( !socket_full( sctx->sock, 3 ) )
|
||||
{
|
||||
applog( LOG_WARNING, "Extranonce disabled, subscribe timed out" );
|
||||
opt_extranonce = false;
|
||||
goto out;
|
||||
}
|
||||
if ( !opt_quiet )
|
||||
applog( LOG_INFO, "Extranonce subscription enabled" );
|
||||
|
||||
sret = stratum_recv_line(sctx);
|
||||
if (sret) {
|
||||
json_t *extra = JSON_LOADS(sret, &err);
|
||||
if (!extra) {
|
||||
sret = stratum_recv_line( sctx );
|
||||
if ( sret )
|
||||
{
|
||||
json_t *extra = JSON_LOADS( sret, &err );
|
||||
if ( !extra )
|
||||
{
|
||||
applog(LOG_WARNING, "JSON decode failed(%d): %s", err.line, err.text);
|
||||
} else {
|
||||
if (json_integer_value(json_object_get(extra, "id")) != 3) {
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( json_integer_value(json_object_get( extra, "id" ) ) != 3 )
|
||||
{
|
||||
// we receive a standard method if extranonce is ignored
|
||||
if (!stratum_handle_method(sctx, sret))
|
||||
applog(LOG_WARNING, "Stratum answer id is not correct!");
|
||||
if ( !stratum_handle_method( sctx, sret ) )
|
||||
applog( LOG_WARNING, "Stratum answer id is not correct!" );
|
||||
}
|
||||
res_val = json_object_get(extra, "result");
|
||||
res_val = json_object_get( extra, "result" );
|
||||
// if (opt_debug && (!res_val || json_is_false(res_val)))
|
||||
// applog(LOG_DEBUG, "extranonce subscribe not supported");
|
||||
json_decref(extra);
|
||||
json_decref( extra );
|
||||
}
|
||||
free(sret);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user