From 4073fd4aa2b8f78058fa295806af47cab8b87826 Mon Sep 17 00:00:00 2001 From: Tanguy Pruvot Date: Fri, 12 Jan 2018 17:27:59 +0100 Subject: [PATCH] x16r algo: beware, this algo hashrate is not constant unlike timetravel, a fast algo can be used 16 times in theory Signed-off-by: Tanguy Pruvot --- Makefile.am | 1 + NEWS | 1 + README.md | 1 + algo/x16r.c | 230 +++++++++++++++++++++++++++++++++++++++ cpu-miner.c | 8 ++ cpuminer.vcxproj | 1 + cpuminer.vcxproj.filters | 3 + miner.h | 2 + util.c | 3 + 9 files changed, 250 insertions(+) create mode 100644 algo/x16r.c diff --git a/Makefile.am b/Makefile.am index 3e0294a..0cc6ff1 100644 --- a/Makefile.am +++ b/Makefile.am @@ -99,6 +99,7 @@ cpuminer_SOURCES = \ algo/x13.c \ algo/x14.c \ algo/x15.c \ + algo/x16r.c \ algo/x17.c \ algo/xevan.c \ algo/yescrypt.c \ diff --git a/NEWS b/NEWS index 0509caf..b941ab9 100644 --- a/NEWS +++ b/NEWS @@ -1,5 +1,6 @@ Version 1.3.3 - Add tribus algo +- Add x16r algo Version 1.3.2 - Add bitcore algo diff --git a/README.md b/README.md index c81eeef..250774a 100644 --- a/README.md +++ b/README.md @@ -62,6 +62,7 @@ Algorithms * ✓ __x13__ (Sherlockcoin, [ACE], [B2B], [GRC], [XHC], ...) * ✓ __x14__ (X14, Webcoin [WEB]) * ✓ __x15__ (RadianceCoin [RCE]) + * ✓ __x16r__ (Ravencoin [RVN]) * ✓ __x17__ (Verge [XVG]) * ✓ __yescrypt__ (GlobalBoostY [BSTY], Unitus [UIS], MyriadCoin [MYR]) * ✓ __zr5__ (Ziftrcoin [ZRC]) diff --git a/algo/x16r.c b/algo/x16r.c new file mode 100644 index 0000000..f6f3608 --- /dev/null +++ b/algo/x16r.c @@ -0,0 +1,230 @@ +/** + * x16r algo implementation + * + * Implementation by tpruvot@github Jan 2018 + */ +#include "miner.h" + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +enum Algo { + BLAKE = 0, + BMW, + GROESTL, + JH, + KECCAK, + SKEIN, + LUFFA, + CUBEHASH, + SHAVITE, + SIMD, + ECHO, + HAMSI, + FUGUE, + SHABAL, + WHIRLPOOL, + SHA512, + HASH_FUNC_COUNT +}; + +static __thread uint32_t s_ntime = UINT32_MAX; +static __thread char hashOrder[HASH_FUNC_COUNT + 1] = { 0 }; + +static void getAlgoString(const uint8_t* prevblock, char *output) +{ + char *sptr = output; + for (int j = 0; j < HASH_FUNC_COUNT; j++) { + uint8_t b = (15 - j) >> 1; // 16 first ascii hex chars (lsb in uint256) + uint8_t algoDigit = (j & 1) ? prevblock[b] & 0xF : prevblock[b] >> 4; + if (algoDigit >= 10) + sprintf(sptr, "%c", 'A' + (algoDigit - 10)); + else + sprintf(sptr, "%u", (uint32_t) algoDigit); + sptr++; + } + *sptr = '\0'; +} + +void x16r_hash(void* output, const void* input) +{ + uint32_t _ALIGN(128) hash[64/4]; + + sph_blake512_context ctx_blake; + sph_bmw512_context ctx_bmw; + sph_groestl512_context ctx_groestl; + sph_skein512_context ctx_skein; + sph_jh512_context ctx_jh; + sph_keccak512_context ctx_keccak; + sph_luffa512_context ctx_luffa1; + sph_cubehash512_context ctx_cubehash1; + sph_shavite512_context ctx_shavite1; + sph_simd512_context ctx_simd1; + sph_echo512_context ctx_echo1; + sph_hamsi512_context ctx_hamsi1; + sph_fugue512_context ctx_fugue1; + sph_shabal512_context ctx_shabal1; + sph_whirlpool_context ctx_whirlpool1; + sph_sha512_context ctx_sha512; + + void *in = (void*) input; + int size = 80; + + if (s_ntime == UINT32_MAX) { + const uint8_t* in8 = (uint8_t*) input; + getAlgoString(&in8[4], hashOrder); + } + + for (int i = 0; i < 16; i++) + { + const char elem = hashOrder[i]; + const uint8_t algo = elem >= 'A' ? elem - 'A' + 10 : elem - '0'; + + switch (algo) { + case BLAKE: + sph_blake512_init(&ctx_blake); + sph_blake512(&ctx_blake, in, size); + sph_blake512_close(&ctx_blake, hash); + break; + case BMW: + sph_bmw512_init(&ctx_bmw); + sph_bmw512(&ctx_bmw, in, size); + sph_bmw512_close(&ctx_bmw, hash); + break; + case GROESTL: + sph_groestl512_init(&ctx_groestl); + sph_groestl512(&ctx_groestl, in, size); + sph_groestl512_close(&ctx_groestl, hash); + break; + case SKEIN: + sph_skein512_init(&ctx_skein); + sph_skein512(&ctx_skein, in, size); + sph_skein512_close(&ctx_skein, hash); + break; + case JH: + sph_jh512_init(&ctx_jh); + sph_jh512(&ctx_jh, in, size); + sph_jh512_close(&ctx_jh, hash); + break; + case KECCAK: + sph_keccak512_init(&ctx_keccak); + sph_keccak512(&ctx_keccak, in, size); + sph_keccak512_close(&ctx_keccak, hash); + break; + case LUFFA: + sph_luffa512_init(&ctx_luffa1); + sph_luffa512(&ctx_luffa1, in, size); + sph_luffa512_close(&ctx_luffa1, hash); + break; + case CUBEHASH: + sph_cubehash512_init(&ctx_cubehash1); + sph_cubehash512(&ctx_cubehash1, in, size); + sph_cubehash512_close(&ctx_cubehash1, hash); + break; + case SHAVITE: + sph_shavite512_init(&ctx_shavite1); + sph_shavite512(&ctx_shavite1, in, size); + sph_shavite512_close(&ctx_shavite1, hash); + break; + case SIMD: + sph_simd512_init(&ctx_simd1); + sph_simd512(&ctx_simd1, in, size); + sph_simd512_close(&ctx_simd1, hash); + break; + case ECHO: + sph_echo512_init(&ctx_echo1); + sph_echo512(&ctx_echo1, in, size); + sph_echo512_close(&ctx_echo1, hash); + break; + case HAMSI: + sph_hamsi512_init(&ctx_hamsi1); + sph_hamsi512(&ctx_hamsi1, in, size); + sph_hamsi512_close(&ctx_hamsi1, hash); + break; + case FUGUE: + sph_fugue512_init(&ctx_fugue1); + sph_fugue512(&ctx_fugue1, in, size); + sph_fugue512_close(&ctx_fugue1, hash); + break; + case SHABAL: + sph_shabal512_init(&ctx_shabal1); + sph_shabal512(&ctx_shabal1, in, size); + sph_shabal512_close(&ctx_shabal1, hash); + break; + case WHIRLPOOL: + sph_whirlpool_init(&ctx_whirlpool1); + sph_whirlpool(&ctx_whirlpool1, in, size); + sph_whirlpool_close(&ctx_whirlpool1, hash); + break; + case SHA512: + sph_sha512_init(&ctx_sha512); + sph_sha512(&ctx_sha512,(const void*) in, size); + sph_sha512_close(&ctx_sha512,(void*) hash); + break; + } + in = (void*) hash; + size = 64; + } + memcpy(output, hash, 32); +} + +int scanhash_x16r(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done) +{ + uint32_t _ALIGN(128) hash32[8]; + uint32_t _ALIGN(128) endiandata[20]; + uint32_t *pdata = work->data; + uint32_t *ptarget = work->target; + const uint32_t Htarg = ptarget[7]; + const uint32_t first_nonce = pdata[19]; + uint32_t nonce = first_nonce; + volatile uint8_t *restart = &(work_restart[thr_id].restart); + + for (int k=0; k < 19; k++) + be32enc(&endiandata[k], pdata[k]); + + if (s_ntime != pdata[17]) { + uint32_t ntime = swab32(pdata[17]); + getAlgoString((const char*) (&endiandata[1]), hashOrder); + s_ntime = ntime; + if (opt_debug && !thr_id) applog(LOG_DEBUG, "hash order %s (%08x)", hashOrder, ntime); + } + + if (opt_benchmark) + ptarget[7] = 0x0cff; + + do { + be32enc(&endiandata[19], nonce); + x16r_hash(hash32, endiandata); + + if (hash32[7] <= Htarg && fulltest(hash32, ptarget)) { + work_set_target_ratio(work, hash32); + pdata[19] = nonce; + *hashes_done = pdata[19] - first_nonce; + return 1; + } + nonce++; + + } while (nonce < max_nonce && !(*restart)); + + pdata[19] = nonce; + *hashes_done = pdata[19] - first_nonce + 1; + return 0; +} diff --git a/cpu-miner.c b/cpu-miner.c index 9730fb6..53d1cc0 100644 --- a/cpu-miner.c +++ b/cpu-miner.c @@ -124,6 +124,7 @@ enum algos { ALGO_X13, /* X13 */ ALGO_X14, /* X14 */ ALGO_X15, /* X15 */ + ALGO_X16R, ALGO_X17, /* X17 */ ALGO_XEVAN, ALGO_YESCRYPT, @@ -179,6 +180,7 @@ static const char *algo_names[] = { "x13", "x14", "x15", + "x16r", "x17", "xevan", "yescrypt", @@ -332,6 +334,7 @@ Options:\n\ x13 X13\n\ x14 X14\n\ x15 X15\n\ + x16r X16R (Raven)\n\ x17 X17\n\ xevan Xevan (BitSend)\n\ yescrypt Yescrypt\n\ @@ -1800,6 +1803,7 @@ static void stratum_gen_work(struct stratum_ctx *sctx, struct work *work) case ALGO_TIMETRAVEL: case ALGO_BITCORE: case ALGO_XEVAN: + case ALGO_X16R: work_set_target(work, sctx->job.diff / (256.0 * opt_diff_factor)); break; case ALGO_KECCAK: @@ -2144,6 +2148,7 @@ static void *miner_thread(void *userdata) case ALGO_LBRY: case ALGO_TRIBUS: case ALGO_X15: + case ALGO_X16R: case ALGO_X17: case ALGO_ZR5: max64 = 0x1ffff; @@ -2322,6 +2327,9 @@ static void *miner_thread(void *userdata) case ALGO_X15: rc = scanhash_x15(thr_id, &work, max_nonce, &hashes_done); break; + case ALGO_X16R: + rc = scanhash_x16r(thr_id, &work, max_nonce, &hashes_done); + break; case ALGO_X17: rc = scanhash_x17(thr_id, &work, max_nonce, &hashes_done); break; diff --git a/cpuminer.vcxproj b/cpuminer.vcxproj index 141e9f0..aace24d 100644 --- a/cpuminer.vcxproj +++ b/cpuminer.vcxproj @@ -249,6 +249,7 @@ + diff --git a/cpuminer.vcxproj.filters b/cpuminer.vcxproj.filters index 707b986..7232128 100644 --- a/cpuminer.vcxproj.filters +++ b/cpuminer.vcxproj.filters @@ -285,6 +285,9 @@ algo + + algo + algo diff --git a/miner.h b/miner.h index 45e9431..e48bf7f 100644 --- a/miner.h +++ b/miner.h @@ -247,6 +247,7 @@ int scanhash_x11(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *ha int scanhash_x13(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done); int scanhash_x14(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done); int scanhash_x15(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done); +int scanhash_x16r(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done); int scanhash_x17(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done); int scanhash_xevan(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done); int scanhash_yescrypt(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done); @@ -533,6 +534,7 @@ void x11hash(void *output, const void *input); void x13hash(void *output, const void *input); void x14hash(void *output, const void *input); void x15hash(void *output, const void *input); +void x16r_hash(void *output, const void *input); void x17hash(void *output, const void *input); void zr5hash(void *output, const void *input); void yescrypthash(void *output, const void *input); diff --git a/util.c b/util.c index 5cecf84..1f987bf 100644 --- a/util.c +++ b/util.c @@ -2456,6 +2456,9 @@ void print_hash_tests(void) x15hash(&hash[0], &buf[0]); printpfx("x15", hash); + x16r_hash(&hash[0], &buf[0]); + printpfx("x16r", hash); + x17hash(&hash[0], &buf[0]); printpfx("x17", hash); -- 2.42.0