forked from lucasjones/cpuminer-multi
-
Notifications
You must be signed in to change notification settings - Fork 697
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
x20r algo with saphir panama and radiogatun (#33)
X20r algo - this is x16r extended with the addition of haval, gost, radioatun and panama + space/tabs cleanup, algo order and missing vstudio files...
- Loading branch information
1 parent
ee9f642
commit ac6e408
Showing
11 changed files
with
1,936 additions
and
1 deletion.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,258 @@ | ||
| #include "miner.h" | ||
|
|
||
| #include <stdio.h> | ||
| #include <stdlib.h> | ||
| #include <string.h> | ||
|
|
||
| #include <sha3/sph_blake.h> | ||
| #include <sha3/sph_bmw.h> | ||
| #include <sha3/sph_groestl.h> | ||
| #include <sha3/sph_jh.h> | ||
| #include <sha3/sph_keccak.h> | ||
| #include <sha3/sph_skein.h> | ||
| #include <sha3/sph_luffa.h> | ||
| #include <sha3/sph_cubehash.h> | ||
| #include <sha3/sph_shavite.h> | ||
| #include <sha3/sph_simd.h> | ||
| #include <sha3/sph_echo.h> | ||
| #include <sha3/sph_hamsi.h> | ||
| #include <sha3/sph_fugue.h> | ||
| #include <sha3/sph_shabal.h> | ||
| #include <sha3/sph_whirlpool.h> | ||
| #include <sha3/sph_sha2.h> | ||
| #include <sha3/sph_haval.h> | ||
| #include <sha3/sph_radiogatun.h> | ||
| #include <sha3/sph_panama.h> | ||
| #include <sha3/gost_streebog.h> | ||
|
|
||
| enum Algo { | ||
| BLAKE = 0, | ||
| BMW, | ||
| GROESTL, | ||
| JH, | ||
| KECCAK, | ||
| SKEIN, | ||
| LUFFA, | ||
| CUBEHASH, | ||
| SHAVITE, | ||
| SIMD, | ||
| ECHO, | ||
| HAMSI, | ||
| FUGUE, | ||
| SHABAL, | ||
| WHIRLPOOL, | ||
| SHA512, | ||
| HAVAL, | ||
| GOST, | ||
| RADIOGATUN, | ||
| PANAMA, | ||
| 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++) { | ||
| char b = (19 - j) >> 1; // 16 ascii hex chars, reversed | ||
| 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 x20r_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_luffa; | ||
| sph_cubehash512_context ctx_cubehash; | ||
| sph_shavite512_context ctx_shavite; | ||
| sph_simd512_context ctx_simd; | ||
| sph_echo512_context ctx_echo; | ||
| sph_hamsi512_context ctx_hamsi; | ||
| sph_fugue512_context ctx_fugue; | ||
| sph_shabal512_context ctx_shabal; | ||
| sph_whirlpool_context ctx_whirlpool; | ||
| sph_sha512_context ctx_sha512; | ||
| sph_haval256_5_context ctx_haval; | ||
| sph_gost512_context ctx_gost; | ||
| sph_radiogatun64_context ctx_radiogatun; | ||
| sph_panama_context ctx_panama; | ||
|
|
||
| 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 < 20; 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_luffa); | ||
| sph_luffa512(&ctx_luffa, in, size); | ||
| sph_luffa512_close(&ctx_luffa, hash); | ||
| break; | ||
| case CUBEHASH: | ||
| sph_cubehash512_init(&ctx_cubehash); | ||
| sph_cubehash512(&ctx_cubehash, in, size); | ||
| sph_cubehash512_close(&ctx_cubehash, hash); | ||
| break; | ||
| case SHAVITE: | ||
| sph_shavite512_init(&ctx_shavite); | ||
| sph_shavite512(&ctx_shavite, in, size); | ||
| sph_shavite512_close(&ctx_shavite, hash); | ||
| break; | ||
| case SIMD: | ||
| sph_simd512_init(&ctx_simd); | ||
| sph_simd512(&ctx_simd, in, size); | ||
| sph_simd512_close(&ctx_simd, hash); | ||
| break; | ||
| case ECHO: | ||
| sph_echo512_init(&ctx_echo); | ||
| sph_echo512(&ctx_echo, in, size); | ||
| sph_echo512_close(&ctx_echo, hash); | ||
| break; | ||
| case HAMSI: | ||
| sph_hamsi512_init(&ctx_hamsi); | ||
| sph_hamsi512(&ctx_hamsi, in, size); | ||
| sph_hamsi512_close(&ctx_hamsi, hash); | ||
| break; | ||
| case FUGUE: | ||
| sph_fugue512_init(&ctx_fugue); | ||
| sph_fugue512(&ctx_fugue, in, size); | ||
| sph_fugue512_close(&ctx_fugue, hash); | ||
| break; | ||
| case SHABAL: | ||
| sph_shabal512_init(&ctx_shabal); | ||
| sph_shabal512(&ctx_shabal, in, size); | ||
| sph_shabal512_close(&ctx_shabal, hash); | ||
| break; | ||
| case WHIRLPOOL: | ||
| sph_whirlpool_init(&ctx_whirlpool); | ||
| sph_whirlpool(&ctx_whirlpool, in, size); | ||
| sph_whirlpool_close(&ctx_whirlpool, 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; | ||
| case HAVAL: | ||
| sph_haval256_5_init(&ctx_haval); | ||
| sph_haval256_5(&ctx_haval, in, size); | ||
| sph_haval256_5_close(&ctx_haval, hash); | ||
| break; | ||
| case GOST: | ||
| sph_gost512_init(&ctx_gost); | ||
| sph_gost512(&ctx_gost, in, size); | ||
| sph_gost512_close(&ctx_gost, hash); | ||
| break; | ||
| case RADIOGATUN: | ||
| sph_radiogatun64_init(&ctx_radiogatun); | ||
| sph_radiogatun64(&ctx_radiogatun, in, size); | ||
| sph_radiogatun64_close(&ctx_radiogatun, hash); | ||
| break; | ||
| case PANAMA: | ||
| sph_panama_init(&ctx_panama); | ||
| sph_panama(&ctx_panama, in, size); | ||
| sph_panama_close(&ctx_panama, hash); | ||
| break; | ||
| } | ||
| in = (void*) hash; | ||
| size = 64; | ||
| } | ||
| memcpy(output, hash, 32); | ||
| } | ||
|
|
||
| int scanhash_x20r(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); | ||
| x20r_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; | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.