GOSTSec/ccminer-gostd-lite
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

start v1.7, apply new prototypes to all algos

Browse Source
This commit is contained in:
Tanguy Pruvot 2015-09-23 11:56:47 +02:00
parent 4babf37256
commit 5308898d1c
35 changed files with 347 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Algo256/blake256.cu
View File

@ -379,17 +379,18 @@ void blake256_cpu_setBlock_16(uint32_t *penddata, const uint32_t *midstate, cons
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_blake256(int thr_id, uint32_t *pdata, const uint32_t *ptarget, extern "C" int scanhash_blake256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done, int8_t blakerounds=14)
uint32_t max_nonce, unsigned long *hashes_done, int8_t blakerounds=14)
{ {
const uint32_t first_nonce = pdata[19];
uint64_t targetHigh = ((uint64_t*)ptarget)[3];
uint32_t _ALIGN(64) endiandata[20]; uint32_t _ALIGN(64) endiandata[20];
#if PRECALC64 #if PRECALC64
uint32_t _ALIGN(64) midstate[8]; uint32_t _ALIGN(64) midstate[8];
#else #else
uint32_t crcsum; uint32_t crcsum;
#endif #endif
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19];
uint64_t targetHigh = ((uint64_t*)ptarget)[3];
int intensity = (device_sm[device_map[thr_id]] > 500) ? 22 : 20; int intensity = (device_sm[device_map[thr_id]] > 500) ? 22 : 20;
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity);
throughput = min(throughput, max_nonce - first_nonce); throughput = min(throughput, max_nonce - first_nonce);

8
Algo256/bmw.cu
View File

@ -37,9 +37,11 @@ static __inline uint32_t swab32_if(uint32_t val, bool iftrue) {
return iftrue ? swab32(val) : val; return iftrue ? swab32(val) : val;
} }
extern "C" int scanhash_bmw(int thr_id, uint32_t *pdata, const uint32_t *ptarget, extern "C" int scanhash_bmw(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
bool swapnonce = true; bool swapnonce = true;
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 21); uint32_t throughput = device_intensity(thr_id, __func__, 1U << 21);
@ -59,7 +61,6 @@ extern "C" int scanhash_bmw(int thr_id, uint32_t *pdata, const uint32_t *ptarget
init[thr_id] = true; init[thr_id] = true;
} }
uint32_t endiandata[20];
for (int k=0; k < 20; k++) { for (int k=0; k < 20; k++) {
be32enc(&endiandata[k], ((uint32_t*)pdata)[k]); be32enc(&endiandata[k], ((uint32_t*)pdata)[k]);
} }
@ -80,6 +81,7 @@ extern "C" int scanhash_bmw(int thr_id, uint32_t *pdata, const uint32_t *ptarget
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
*hashes_done = foundNonce - first_nonce + 1; *hashes_done = foundNonce - first_nonce + 1;
pdata[19] = swab32_if(foundNonce,!swapnonce); pdata[19] = swab32_if(foundNonce,!swapnonce);
bn_store_hash_target_ratio(vhash64, ptarget, work);
return 1; return 1;
} }
else { else {

9
Algo256/keccak256.cu
View File

@ -35,10 +35,11 @@ extern "C" void keccak256_hash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_keccak256(int thr_id, uint32_t *pdata, extern "C" int scanhash_keccak256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 21); // 256*256*8*4 uint32_t throughput = device_intensity(thr_id, __func__, 1U << 21); // 256*256*8*4
throughput = min(throughput, max_nonce - first_nonce); throughput = min(throughput, max_nonce - first_nonce);
@ -55,7 +56,6 @@ extern "C" int scanhash_keccak256(int thr_id, uint32_t *pdata,
init[thr_id] = true; init[thr_id] = true;
} }
uint32_t endiandata[20];
for (int k=0; k < 20; k++) { for (int k=0; k < 20; k++) {
be32enc(&endiandata[k], pdata[k]); be32enc(&endiandata[k], pdata[k]);
} }
@ -74,6 +74,7 @@ extern "C" int scanhash_keccak256(int thr_id, uint32_t *pdata,
keccak256_hash(vhash64, endiandata); keccak256_hash(vhash64, endiandata);
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[19] = foundNonce; pdata[19] = foundNonce;
return 1; return 1;
} }

13
JHA/jackpotcoin.cu
View File

@ -87,10 +87,11 @@ extern "C" unsigned int jackpothash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_jackpot(int thr_id, uint32_t *pdata, extern "C" int scanhash_jackpot(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[22];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 20); uint32_t throughput = device_intensity(thr_id, __func__, 1U << 20);
@ -123,7 +124,6 @@ extern "C" int scanhash_jackpot(int thr_id, uint32_t *pdata,
init[thr_id] = true; init[thr_id] = true;
} }
uint32_t endiandata[22];
for (int k=0; k < 22; k++) for (int k=0; k < 22; k++)
be32enc(&endiandata[k], pdata[k]); be32enc(&endiandata[k], pdata[k]);
@ -221,7 +221,12 @@ extern "C" int scanhash_jackpot(int thr_id, uint32_t *pdata,
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
nist5hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

5
README.txt
View File

@ -142,6 +142,7 @@ its command line interface and options.
--pstate=0 will force the Geforce 9xx to run in P0 P-State --pstate=0 will force the Geforce 9xx to run in P0 P-State
--plimit=150W set the gpu power limit, allow multiple values for N cards --plimit=150W set the gpu power limit, allow multiple values for N cards
--keep-clocks prevent reset clocks and/or power limit on exit --keep-clocks prevent reset clocks and/or power limit on exit
--show-diff display submitted block and net difficulty
-B, --background run the miner in the background -B, --background run the miner in the background
--benchmark run in offline benchmark mode --benchmark run in offline benchmark mode
--cputest debug hashes from cpu algorithms --cputest debug hashes from cpu algorithms
@ -226,8 +227,10 @@ features.
>>> RELEASE HISTORY <<< >>> RELEASE HISTORY <<<
Under Dev... v1.6.7 Under Dev... v1.7
Add --cuda-schedule parameter Add --cuda-schedule parameter
Add --show-diff parameter, which display shares diff,
and is able to detect real solved blocks on pools.
Aug. 28th 2015 v1.6.6 Aug. 28th 2015 v1.6.6
Allow to load remote config with curl (-c http://...) Allow to load remote config with curl (-c http://...)

149
ccminer.cpp
View File

@ -1873,165 +1873,106 @@ static void *miner_thread(void *userdata)
/* scan nonces for a proof-of-work hash */ /* scan nonces for a proof-of-work hash */
switch (opt_algo) { switch (opt_algo) {
case ALGO_HEAVY:
rc = scanhash_heavy(thr_id, work.data, work.target,
max_nonce, &hashes_done, work.maxvote, HEAVYCOIN_BLKHDR_SZ);
break;
case ALGO_KECCAK:
rc = scanhash_keccak256(thr_id, work.data, work.target,
max_nonce, &hashes_done);
break;
case ALGO_MJOLLNIR:
rc = scanhash_heavy(thr_id, work.data, work.target,
max_nonce, &hashes_done, 0, MNR_BLKHDR_SZ);
break;
case ALGO_DEEP:
rc = scanhash_deep(thr_id, work.data, work.target,
max_nonce, &hashes_done);
break;
case ALGO_LUFFA:
rc = scanhash_luffa(thr_id, work.data, work.target,
max_nonce, &hashes_done);
break;
case ALGO_BLAKECOIN: case ALGO_BLAKECOIN:
rc = scanhash_blake256(thr_id, work.data, work.target, rc = scanhash_blake256(thr_id, &work, max_nonce, &hashes_done, 8);
max_nonce, &hashes_done, 8);
break; break;
case ALGO_BLAKE: case ALGO_BLAKE:
rc = scanhash_blake256(thr_id, work.data, work.target, rc = scanhash_blake256(thr_id, &work, max_nonce, &hashes_done, 14);
max_nonce, &hashes_done, 14);
break; break;
case ALGO_BMW: case ALGO_BMW:
rc = scanhash_bmw(thr_id, work.data, work.target, max_nonce, &hashes_done); rc = scanhash_bmw(thr_id, &work, max_nonce, &hashes_done);
break; break;
case ALGO_C11: case ALGO_C11:
rc = scanhash_c11(thr_id, work.data, work.target, rc = scanhash_c11(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done); break;
case ALGO_DEEP:
rc = scanhash_deep(thr_id, &work, max_nonce, &hashes_done);
break;
case ALGO_FRESH:
rc = scanhash_fresh(thr_id, &work, max_nonce, &hashes_done);
break; break;
case ALGO_FUGUE256: case ALGO_FUGUE256:
rc = scanhash_fugue256(thr_id, work.data, work.target, rc = scanhash_fugue256(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_GROESTL: case ALGO_GROESTL:
case ALGO_DMD_GR: case ALGO_DMD_GR:
rc = scanhash_groestlcoin(thr_id, work.data, work.target, rc = scanhash_groestlcoin(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_MYR_GR: case ALGO_MYR_GR:
rc = scanhash_myriad(thr_id, work.data, work.target, rc = scanhash_myriad(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_HEAVY:
rc = scanhash_heavy(thr_id, &work, max_nonce, &hashes_done, work.maxvote, HEAVYCOIN_BLKHDR_SZ);
break;
case ALGO_MJOLLNIR:
rc = scanhash_heavy(thr_id, &work, max_nonce, &hashes_done, 0, MNR_BLKHDR_SZ);
break;
case ALGO_KECCAK:
rc = scanhash_keccak256(thr_id, &work, max_nonce, &hashes_done);
break;
case ALGO_JACKPOT: case ALGO_JACKPOT:
rc = scanhash_jackpot(thr_id, work.data, work.target, rc = scanhash_jackpot(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done); break;
case ALGO_LUFFA:
rc = scanhash_luffa(thr_id, &work, max_nonce, &hashes_done);
break; break;
case ALGO_QUARK: case ALGO_QUARK:
rc = scanhash_quark(thr_id, work.data, work.target, rc = scanhash_quark(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_QUBIT: case ALGO_QUBIT:
rc = scanhash_qubit(thr_id, work.data, work.target, rc = scanhash_qubit(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_FRESH:
rc = scanhash_fresh(thr_id, work.data, work.target,
max_nonce, &hashes_done);
break;
case ALGO_LYRA2: case ALGO_LYRA2:
rc = scanhash_lyra2(thr_id, work.data, work.target, rc = scanhash_lyra2(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_LYRA2v2: case ALGO_LYRA2v2:
rc = scanhash_lyra2v2(thr_id, &work, max_nonce, &hashes_done); rc = scanhash_lyra2v2(thr_id, &work, max_nonce, &hashes_done);
break; break;
case ALGO_NEOSCRYPT: case ALGO_NEOSCRYPT:
rc = scanhash_neoscrypt(thr_id, work.data, work.target, rc = scanhash_neoscrypt(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_NIST5: case ALGO_NIST5:
rc = scanhash_nist5(thr_id, work.data, work.target, rc = scanhash_nist5(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_PENTABLAKE: case ALGO_PENTABLAKE:
rc = scanhash_pentablake(thr_id, work.data, work.target, rc = scanhash_pentablake(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_SCRYPT: case ALGO_SCRYPT:
rc = scanhash_scrypt(thr_id, work.data, work.target, NULL, rc = scanhash_scrypt(thr_id, &work, max_nonce, &hashes_done,
max_nonce, &hashes_done, &tv_start, &tv_end); NULL, &tv_start, &tv_end);
break; break;
case ALGO_SCRYPT_JANE: case ALGO_SCRYPT_JANE:
rc = scanhash_scrypt_jane(thr_id, work.data, work.target, NULL, rc = scanhash_scrypt_jane(thr_id, &work, max_nonce, &hashes_done,
max_nonce, &hashes_done, &tv_start, &tv_end); NULL, &tv_start, &tv_end);
break; break;
case ALGO_SKEIN: case ALGO_SKEIN:
rc = scanhash_skeincoin(thr_id, work.data, work.target, rc = scanhash_skeincoin(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_SKEIN2: case ALGO_SKEIN2:
rc = scanhash_skein2(thr_id, work.data, work.target, rc = scanhash_skein2(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_S3: case ALGO_S3:
rc = scanhash_s3(thr_id, work.data, work.target, rc = scanhash_s3(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_WHIRLPOOLX: case ALGO_WHIRLPOOLX:
rc = scanhash_whirlpoolx(thr_id, work.data, work.target, rc = scanhash_whirlx(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_X11: case ALGO_X11:
rc = scanhash_x11(thr_id, work.data, work.target, rc = scanhash_x11(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_X13: case ALGO_X13:
rc = scanhash_x13(thr_id, work.data, work.target, rc = scanhash_x13(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_X14: case ALGO_X14:
rc = scanhash_x14(thr_id, work.data, work.target, rc = scanhash_x14(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break;
case ALGO_X15: case ALGO_X15:
rc = scanhash_x15(thr_id, work.data, work.target, rc = scanhash_x15(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_X17: case ALGO_X17:
rc = scanhash_x17(thr_id, work.data, work.target, rc = scanhash_x17(thr_id, &work, max_nonce, &hashes_done);
max_nonce, &hashes_done);
break; break;
case ALGO_ZR5: case ALGO_ZR5:
rc = scanhash_zr5(thr_id, &work, max_nonce, &hashes_done); rc = scanhash_zr5(thr_id, &work, max_nonce, &hashes_done);
break; break;

2
configure.ac
View File

@ -1,4 +1,4 @@
AC_INIT([ccminer], [1.6.7-dev]) AC_INIT([ccminer], [1.7-dev])
AC_PREREQ([2.59c]) AC_PREREQ([2.59c])
AC_CANONICAL_SYSTEM AC_CANONICAL_SYSTEM

6
cpuminer-config.h
View File

@ -162,7 +162,7 @@
#define PACKAGE_NAME "ccminer" #define PACKAGE_NAME "ccminer"
/* Define to the full name and version of this package. */ /* Define to the full name and version of this package. */
#define PACKAGE_STRING "ccminer 1.6.6" #define PACKAGE_STRING "ccminer 1.7-dev"
/* Define to the one symbol short name of this package. */ /* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "ccminer" #define PACKAGE_TARNAME "ccminer"
@ -171,7 +171,7 @@
#define PACKAGE_URL "http://github.com/tpruvot/ccminer" #define PACKAGE_URL "http://github.com/tpruvot/ccminer"
/* Define to the version of this package. */ /* Define to the version of this package. */
#define PACKAGE_VERSION "1.6.6" #define PACKAGE_VERSION "1.7-dev"
/* If using the C implementation of alloca, define if you know the /* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be direction of stack growth for your system; otherwise it will be
@ -185,7 +185,7 @@
#define STDC_HEADERS 1 #define STDC_HEADERS 1
/* Version number of package */ /* Version number of package */
#define VERSION "1.6.6" #define VERSION "1.7-dev"
/* Define curl_free() as free() if our version of curl lacks curl_free. */ /* Define curl_free() as free() if our version of curl lacks curl_free. */
/* #undef curl_free */ /* #undef curl_free */

16
cuda_nist5.cu
View File

@ -66,10 +66,11 @@ extern "C" void nist5hash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_nist5(int thr_id, uint32_t *pdata, extern "C" int scanhash_nist5(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 20); // 256*256*16 uint32_t throughput = device_intensity(thr_id, __func__, 1 << 20); // 256*256*16
@ -95,7 +96,6 @@ extern "C" int scanhash_nist5(int thr_id, uint32_t *pdata,
init[thr_id] = true; init[thr_id] = true;
} }
uint32_t endiandata[20];
for (int k=0; k < 20; k++) for (int k=0; k < 20; k++)
be32enc(&endiandata[k], pdata[k]); be32enc(&endiandata[k], pdata[k]);
@ -112,6 +112,8 @@ extern "C" int scanhash_nist5(int thr_id, uint32_t *pdata,
quark_keccak512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); quark_keccak512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + throughput;
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
{ {
@ -123,8 +125,12 @@ extern "C" int scanhash_nist5(int thr_id, uint32_t *pdata,
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) { if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
nist5hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

21
fuguecoin.cpp
View File

@ -22,9 +22,11 @@ extern "C" void my_fugue256_addbits_and_close(void *cc, unsigned ub, unsigned n,
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
int scanhash_fugue256(int thr_id, uint32_t *pdata, const uint32_t *ptarget, int scanhash_fugue256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
uint32_t start_nonce = pdata[19]++; uint32_t start_nonce = pdata[19]++;
int intensity = (device_sm[device_map[thr_id]] > 500) ? 22 : 19; int intensity = (device_sm[device_map[thr_id]] > 500) ? 22 : 19;
uint32_t throughput = device_intensity(thr_id, __func__, 1 << intensity); // 256*256*8 uint32_t throughput = device_intensity(thr_id, __func__, 1 << intensity); // 256*256*8
@ -42,8 +44,7 @@ int scanhash_fugue256(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
init[thr_id] = true; init[thr_id] = true;
} }
// Endian Drehung ist notwendig // Endian
uint32_t endiandata[20];
for (int kk=0; kk < 20; kk++) for (int kk=0; kk < 20; kk++)
be32enc(&endiandata[kk], pdata[kk]); be32enc(&endiandata[kk], pdata[kk]);
@ -57,17 +58,17 @@ int scanhash_fugue256(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
if (foundNounce < UINT32_MAX) if (foundNounce < UINT32_MAX)
{ {
uint32_t hash[8]; uint32_t vhash[8];
const uint32_t Htarg = ptarget[7];
endiandata[19] = SWAP32(foundNounce);
sph_fugue256_context ctx_fugue; sph_fugue256_context ctx_fugue;
endiandata[19] = SWAP32(foundNounce);
sph_fugue256_init(&ctx_fugue); sph_fugue256_init(&ctx_fugue);
sph_fugue256 (&ctx_fugue, endiandata, 80); sph_fugue256 (&ctx_fugue, endiandata, 80);
sph_fugue256_close(&ctx_fugue, &hash); sph_fugue256_close(&ctx_fugue, &vhash);
if (hash[7] <= Htarg && fulltest(hash, ptarget)) if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget))
{ {
bn_store_hash_target_ratio(vhash, ptarget, work);
pdata[19] = foundNounce; pdata[19] = foundNounce;
*hashes_done = foundNounce - start_nonce + 1; *hashes_done = foundNounce - start_nonce + 1;
return 1; return 1;

14
groestlcoin.cpp
View File

@ -27,10 +27,11 @@ void groestlhash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
int scanhash_groestlcoin(int thr_id, uint32_t *pdata, const uint32_t *ptarget, int scanhash_groestlcoin(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20]; uint32_t _ALIGN(64) endiandata[32];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
uint32_t start_nonce = pdata[19]; uint32_t start_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 19); // 256*256*8 uint32_t throughput = device_intensity(thr_id, __func__, 1 << 19); // 256*256*8
throughput = min(throughput, max_nonce - start_nonce); throughput = min(throughput, max_nonce - start_nonce);
@ -62,11 +63,12 @@ int scanhash_groestlcoin(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
if (foundNounce < UINT32_MAX) if (foundNounce < UINT32_MAX)
{ {
uint32_t _ALIGN(64) tmpHash[8]; uint32_t _ALIGN(64) vhash[8];
endiandata[19] = swab32(foundNounce); endiandata[19] = swab32(foundNounce);
groestlhash(tmpHash, endiandata); groestlhash(vhash, endiandata);
if (tmpHash[7] <= ptarget[7] && fulltest(tmpHash, ptarget)) { if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
bn_store_hash_target_ratio(vhash, ptarget, work);
pdata[19] = foundNounce; pdata[19] = foundNounce;
free(outputHash); free(outputHash);
return true; return true;

19
heavy/heavy.cu
View File

@ -130,10 +130,10 @@ struct check_nonce_for_remove
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
__host__ __host__
int scanhash_heavy(int thr_id, uint32_t *pdata, int scanhash_heavy(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done, uint32_t maxvote, int blocklen)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done, uint32_t maxvote, int blocklen)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
// CUDA will process thousands of threads. // CUDA will process thousands of threads.
uint32_t throughput = device_intensity(thr_id, __func__, (1U << 19) - 256); uint32_t throughput = device_intensity(thr_id, __func__, (1U << 19) - 256);
@ -271,22 +271,21 @@ int scanhash_heavy(int thr_id, uint32_t *pdata,
{ {
uint32_t nonce = cpu_nonceVector[i]; uint32_t nonce = cpu_nonceVector[i];
uint32_t *foundhash = &hash[8*i]; uint32_t *foundhash = &hash[8*i];
if (foundhash[7] <= ptarget[7]) { if (foundhash[7] <= ptarget[7] && fulltest(foundhash, ptarget)) {
if (fulltest(foundhash, ptarget)) { uint32_t vhash[8];
uint32_t verification[8];
pdata[19] += nonce - pdata[19]; pdata[19] += nonce - pdata[19];
heavycoin_hash((uchar*)verification, (uchar*)pdata, blocklen); heavycoin_hash((uchar*)vhash, (uchar*)pdata, blocklen);
if (memcmp(verification, foundhash, 8*sizeof(uint32_t))) { if (memcmp(vhash, foundhash, 8*sizeof(uint32_t))) {
applog(LOG_ERR, "hash for nonce=$%08X does not validate on CPU!\n", nonce); applog(LOG_ERR, "hash for nonce %08x does not validate on CPU!\n", nonce);
} else { } else {
*hashes_done = pdata[19] - first_nonce; *hashes_done = pdata[19] - first_nonce;
bn_store_hash_target_ratio(vhash, ptarget, work);
rc = 1; rc = 1;
goto exit; goto exit;
} }
} }
} }
} }
}
emptyNonceVector: emptyNonceVector:

9
lyra2/lyra2RE.cu
View File

@ -75,10 +75,10 @@ extern "C" void lyra2re_hash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_lyra2(int thr_id, uint32_t *pdata, extern "C" int scanhash_lyra2(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
int intensity = (device_sm[device_map[thr_id]] >= 500 && !is_windows()) ? 18 : 17; int intensity = (device_sm[device_map[thr_id]] >= 500 && !is_windows()) ? 18 : 17;
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); // 18=256*256*4; uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); // 18=256*256*4;
@ -135,6 +135,7 @@ extern "C" int scanhash_lyra2(int thr_id, uint32_t *pdata,
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = groestl256_getSecNonce(thr_id, 1); uint32_t secNonce = groestl256_getSecNonce(thr_id, 1);
bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != UINT32_MAX) if (secNonce != UINT32_MAX)
{ {
be32enc(&endiandata[19], secNonce); be32enc(&endiandata[19], secNonce);
@ -142,6 +143,8 @@ extern "C" int scanhash_lyra2(int thr_id, uint32_t *pdata,
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
if (opt_debug) if (opt_debug)
applog(LOG_BLUE, "GPU #%d: found second nonce %08x", device_map[thr_id], secNonce); applog(LOG_BLUE, "GPU #%d: found second nonce %08x", device_map[thr_id], secNonce);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

155
miner.h
View File

@ -264,128 +264,41 @@ void sha256d(unsigned char *hash, const unsigned char *data, int len);
struct work; struct work;
extern int scanhash_sha256d(int thr_id, uint32_t *pdata, extern int scanhash_blake256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done, int8_t blakerounds);
const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done); extern int scanhash_bmw(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_c11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_deep(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_keccak256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_fresh(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_fugue256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_groestlcoin(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_heavy(int thr_id,struct work *work, uint32_t max_nonce, unsigned long *hashes_done, uint32_t maxvote, int blocklen);
extern int scanhash_jackpot(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_luffa(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_lyra2(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_lyra2v2(int thr_id,struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_myriad(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_neoscrypt(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_nist5(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_quark(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_qubit(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_skein2(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_s3(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_whirlx(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x13(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x14(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x15(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_x17(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_zr5(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_deep(int thr_id, uint32_t *pdata, extern int scanhash_sha256d(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
const uint32_t *ptarget, uint32_t max_nonce, extern int scanhash_scrypt(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done,
unsigned long *hashes_done); unsigned char *scratchbuf, struct timeval *tv_start, struct timeval *tv_end);
extern int scanhash_scrypt_jane(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done,
extern int scanhash_luffa(int thr_id, uint32_t *pdata, unsigned char *scratchbuf, struct timeval *tv_start, struct timeval *tv_end);
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_fugue256(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_groestlcoin(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_heavy(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done, uint32_t maxvote, int blocklen);
extern int scanhash_keccak256(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_myriad(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_jackpot(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_quark(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_blake256(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done, int8_t blakerounds);
extern int scanhash_bmw(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_c11(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_fresh(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_lyra2(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_lyra2v2(int thr_id, struct work *work,
uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_neoscrypt(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done);
extern int scanhash_nist5(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_pentablake(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_qubit(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_scrypt(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, unsigned char *scratchbuf, uint32_t max_nonce,
unsigned long *hashes_done, struct timeval *tv_start, struct timeval *tv_end);
extern int scanhash_scrypt_jane(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, unsigned char *scratchbuf, uint32_t max_nonce,
unsigned long *hashes_done, struct timeval *tv_start, struct timeval *tv_end);
extern int scanhash_skeincoin(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_skein2(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_s3(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_x11(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_x13(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_x14(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_x15(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_x17(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_whirlpoolx(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done);
extern int scanhash_zr5(int thr_id, struct work *work, uint32_t max_nonce,
unsigned long *hashes_done);
/* api related */ /* api related */
void *api_thread(void *userdata); void *api_thread(void *userdata);

12
myriadgroestl.cpp
View File

@ -30,10 +30,11 @@ void myriadhash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
int scanhash_myriad(int thr_id, uint32_t *pdata, const uint32_t *ptarget, int scanhash_myriad(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[32]; uint32_t _ALIGN(64) endiandata[32];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
uint32_t start_nonce = pdata[19]; uint32_t start_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 17); uint32_t throughput = device_intensity(thr_id, __func__, 1 << 17);
throughput = min(throughput, max_nonce - start_nonce); throughput = min(throughput, max_nonce - start_nonce);
@ -67,10 +68,11 @@ int scanhash_myriad(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
if (foundNounce < UINT32_MAX) if (foundNounce < UINT32_MAX)
{ {
uint32_t _ALIGN(64) tmpHash[8]; uint32_t _ALIGN(64) vhash[8];
endiandata[19] = swab32(foundNounce); endiandata[19] = swab32(foundNounce);
myriadhash(tmpHash, endiandata); myriadhash(vhash, endiandata);
if (tmpHash[7] <= ptarget[7] && fulltest(tmpHash, ptarget)) { if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
bn_store_hash_target_ratio(vhash, ptarget, work);
pdata[19] = foundNounce; pdata[19] = foundNounce;
free(outputHash); free(outputHash);
return 1; return 1;

7
neoscrypt/neoscrypt.cpp
View File

@ -8,8 +8,11 @@ extern uint32_t neoscrypt_cpu_hash_k4(int thr_id, uint32_t threads, uint32_t sta
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
int scanhash_neoscrypt(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done) int scanhash_neoscrypt(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
int intensity = is_windows() ? 18 : 19; int intensity = is_windows() ? 18 : 19;
@ -37,7 +40,6 @@ int scanhash_neoscrypt(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uin
init[thr_id] = true; init[thr_id] = true;
} }
uint32_t endiandata[20];
if (have_stratum) { if (have_stratum) {
for (int k = 0; k < 20; k++) for (int k = 0; k < 20; k++)
be32enc(&endiandata[k], pdata[k]); be32enc(&endiandata[k], pdata[k]);
@ -64,6 +66,7 @@ int scanhash_neoscrypt(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uin
neoscrypt((uchar*)vhash64, (uchar*) endiandata, 0x80000620U); neoscrypt((uchar*)vhash64, (uchar*) endiandata, 0x80000620U);
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[19] = foundNonce; pdata[19] = foundNonce;
return 1; return 1;
} else { } else {

22
pentablake.cu
View File

@ -364,11 +364,12 @@ void pentablake_cpu_setBlock_80(uint32_t *pdata, const uint32_t *ptarget)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_pentablake(int thr_id, uint32_t *pdata, const uint32_t *ptarget, extern "C" int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t endiandata[20];
int rc = 0; int rc = 0;
uint32_t throughput = device_intensity(thr_id, __func__, 128U * 2560); // 18.5 uint32_t throughput = device_intensity(thr_id, __func__, 128U * 2560); // 18.5
throughput = min(throughput, max_nonce - first_nonce); throughput = min(throughput, max_nonce - first_nonce);
@ -403,20 +404,25 @@ extern "C" int scanhash_pentablake(int thr_id, uint32_t *pdata, const uint32_t *
pentablake_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], order++); pentablake_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
pentablake_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], order++); pentablake_cpu_hash_64(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + throughput;
uint32_t foundNonce = pentablake_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id], order++); uint32_t foundNonce = pentablake_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
{ {
const uint32_t Htarg = ptarget[7]; uint32_t vhash[8];
uint32_t vhashcpu[8];
be32enc(&endiandata[19], foundNonce); be32enc(&endiandata[19], foundNonce);
pentablakehash(vhashcpu, endiandata); pentablakehash(vhash, endiandata);
if (vhashcpu[7] <= Htarg && fulltest(vhashcpu, ptarget)) { if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
rc = 1; rc = 1;
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash, ptarget, work);
if (extra_results[0] != UINT32_MAX) { if (extra_results[0] != UINT32_MAX) {
// Rare but possible if the throughput is big // Rare but possible if the throughput is big
be32enc(&endiandata[19], extra_results[0]);
pentablakehash(vhash, endiandata);
if (bn_hash_target_ratio(vhash, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash, ptarget, work);
applog(LOG_NOTICE, "GPU found more than one result yippee!"); applog(LOG_NOTICE, "GPU found more than one result yippee!");
pdata[21] = extra_results[0]; pdata[21] = extra_results[0];
extra_results[0] = UINT32_MAX; extra_results[0] = UINT32_MAX;

16
quark/quarkcoin.cu
View File

@ -131,10 +131,11 @@ extern "C" void quarkhash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_quark(int thr_id, uint32_t *pdata, extern "C" int scanhash_quark(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 20); // 256*4096 uint32_t throughput = device_intensity(thr_id, __func__, 1 << 20); // 256*4096
@ -166,7 +167,6 @@ extern "C" int scanhash_quark(int thr_id, uint32_t *pdata,
init[thr_id] = true; init[thr_id] = true;
} }
uint32_t endiandata[20];
for (int k=0; k < 20; k++) for (int k=0; k < 20; k++)
be32enc(&endiandata[k], pdata[k]); be32enc(&endiandata[k], pdata[k]);
@ -226,19 +226,19 @@ extern "C" int scanhash_quark(int thr_id, uint32_t *pdata,
// das ist der bedingte Branch für JH512 // das ist der bedingte Branch für JH512
quark_jh512_cpu_hash_64(thr_id, nrm2, pdata[19], d_branch2Nonces[thr_id], d_hash[thr_id], order++); quark_jh512_cpu_hash_64(thr_id, nrm2, pdata[19], d_branch2Nonces[thr_id], d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + 1;
// Scan nach Gewinner Hashes auf der GPU // Scan nach Gewinner Hashes auf der GPU
uint32_t foundNonce = cuda_check_hash_branch(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++); uint32_t foundNonce = cuda_check_hash_branch(thr_id, nrm3, pdata[19], d_branch3Nonces[thr_id], d_hash[thr_id], order++);
if (foundNonce != 0xffffffff) if (foundNonce != 0xffffffff)
{ {
const uint32_t Htarg = ptarget[7];
uint32_t vhash64[8]; uint32_t vhash64[8];
be32enc(&endiandata[19], foundNonce); be32enc(&endiandata[19], foundNonce);
quarkhash(vhash64, endiandata); quarkhash(vhash64, endiandata);
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[19] = foundNonce; pdata[19] = foundNonce;
*hashes_done = foundNonce - first_nonce + 1;
return 1; return 1;
} else { } else {
applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce); applog(LOG_WARNING, "GPU #%d: result for nonce %08x does not validate on CPU!", device_map[thr_id], foundNonce);

13
qubit/deep.cu
View File

@ -52,10 +52,11 @@ extern "C" void deephash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_deep(int thr_id, uint32_t *pdata, const uint32_t *ptarget, extern "C" int scanhash_deep(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20]; uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 19); // 256*256*8 uint32_t throughput = device_intensity(thr_id, __func__, 1U << 19); // 256*256*8
throughput = min(throughput, (max_nonce - first_nonce)); throughput = min(throughput, (max_nonce - first_nonce));
@ -91,6 +92,8 @@ extern "C" int scanhash_deep(int thr_id, uint32_t *pdata, const uint32_t *ptarge
x11_cubehash512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x11_cubehash512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + throughput;
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
{ {
@ -101,8 +104,12 @@ extern "C" int scanhash_deep(int thr_id, uint32_t *pdata, const uint32_t *ptarge
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
deephash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

7
qubit/luffa.cu
View File

@ -30,10 +30,11 @@ extern "C" void luffa_hash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_luffa(int thr_id, uint32_t *pdata, const uint32_t *ptarget, extern "C" int scanhash_luffa(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20]; uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 22); // 256*256*8*8 uint32_t throughput = device_intensity(thr_id, __func__, 1U << 22); // 256*256*8*8
throughput = min(throughput, max_nonce - first_nonce); throughput = min(throughput, max_nonce - first_nonce);
@ -75,7 +76,7 @@ extern "C" int scanhash_luffa(int thr_id, uint32_t *pdata, const uint32_t *ptarg
luffa_hash(vhash64, endiandata); luffa_hash(vhash64, endiandata);
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
//*hashes_done = min(max_nonce - first_nonce, (uint64_t) pdata[19] - first_nonce + throughput); bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[19] = foundNonce; pdata[19] = foundNonce;
return 1; return 1;
} else { } else {

16
qubit/qubit.cu
View File

@ -74,11 +74,11 @@ extern "C" void qubithash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_qubit(int thr_id, uint32_t *pdata, extern "C" int scanhash_qubit(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t endiandata[20]; uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 19); // 256*256*8 uint32_t throughput = device_intensity(thr_id, __func__, 1U << 19); // 256*256*8
throughput = min(throughput, max_nonce - first_nonce); throughput = min(throughput, max_nonce - first_nonce);
@ -119,6 +119,8 @@ extern "C" int scanhash_qubit(int thr_id, uint32_t *pdata,
x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + throughput;
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
{ {
@ -130,8 +132,12 @@ extern "C" int scanhash_qubit(int thr_id, uint32_t *pdata,
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) { if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
qubithash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

7
scrypt-jane.cpp
View File

@ -430,9 +430,11 @@ unsigned char GetNfactor(unsigned int nTimestamp)
| (((x) >> 8) & 0x0000ff00u) | (((x) >> 24) & 0x000000ffu)) | (((x) >> 8) & 0x0000ff00u) | (((x) >> 24) & 0x000000ffu))
static int s_Nfactor = 0; static int s_Nfactor = 0;
int scanhash_scrypt_jane(int thr_id, uint32_t *pdata, const uint32_t *ptarget, unsigned char *scratchbuf, int scanhash_scrypt_jane(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done,
uint32_t max_nonce, unsigned long *hashes_done, struct timeval *tv_start, struct timeval *tv_end) unsigned char *scratchbuf, struct timeval *tv_start, struct timeval *tv_end)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t Htarg = ptarget[7]; const uint32_t Htarg = ptarget[7];
uint32_t N; uint32_t N;
@ -594,6 +596,7 @@ int scanhash_scrypt_jane(int thr_id, uint32_t *pdata, const uint32_t *ptarget, u
if (memcmp(thash, &hash[cur][8*i], 32) == 0) if (memcmp(thash, &hash[cur][8*i], 32) == 0)
{ {
bn_store_hash_target_ratio(thash, ptarget, work);
*hashes_done = n - pdata[19]; *hashes_done = n - pdata[19];
pdata[19] = tmp_nonce; pdata[19] = tmp_nonce;
scrypt_free(&Vbuf); scrypt_free(&Vbuf);

7
scrypt.cpp
View File

@ -689,10 +689,12 @@ static void computeGold(uint32_t* const input, uint32_t *reference, uchar *scrat
// using SSE2 vectorized HMAC SHA256 on CPU and // using SSE2 vectorized HMAC SHA256 on CPU and
// a salsa core implementation on GPU with CUDA // a salsa core implementation on GPU with CUDA
// //
int scanhash_scrypt(int thr_id, uint32_t *pdata, const uint32_t *ptarget, unsigned char *scratchbuf, int scanhash_scrypt(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done,
uint32_t max_nonce, unsigned long *hashes_done, struct timeval *tv_start, struct timeval *tv_end) unsigned char *scratchbuf, struct timeval *tv_start, struct timeval *tv_end)
{ {
int result = 0; int result = 0;
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
int throughput = cuda_throughput(thr_id); int throughput = cuda_throughput(thr_id);
if(throughput == 0) if(throughput == 0)
@ -904,6 +906,7 @@ int scanhash_scrypt(int thr_id, uint32_t *pdata, const uint32_t *ptarget, unsign
device_map[thr_id], device_name[thr_id], i, cur); device_map[thr_id], device_name[thr_id], i, cur);
} else { } else {
*hashes_done = n - pdata[19]; *hashes_done = n - pdata[19];
bn_store_hash_target_ratio(refhash, ptarget, work);
pdata[19] = nonce[cur] + i; pdata[19] = nonce[cur] + i;
result = 1; result = 1;
goto byebye; goto byebye;

10
skein.cu
View File

@ -346,10 +346,11 @@ static __inline uint32_t swab32_if(uint32_t val, bool iftrue) {
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_skeincoin(int thr_id, uint32_t *pdata, const uint32_t *ptarget, extern "C" int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t _ALIGN(64) endiandata[20]; uint32_t _ALIGN(64) endiandata[20];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
const int swap = 1; const int swap = 1;
@ -425,7 +426,12 @@ extern "C" int scanhash_skeincoin(int thr_id, uint32_t *pdata, const uint32_t *p
endiandata[19] = swab32_if(secNonce, swap); endiandata[19] = swab32_if(secNonce, swap);
skeincoinhash(vhash64, endiandata); skeincoinhash(vhash64, endiandata);
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
bn_store_hash_target_ratio(vhash64, ptarget, work);
// todo: use 19 20 21... zr5 pok to adapt... // todo: use 19 20 21... zr5 pok to adapt...
endiandata[19] = swab32_if(secNonce, swap);
skeincoinhash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[19+res*2] = swab32_if(secNonce, !swap); pdata[19+res*2] = swab32_if(secNonce, !swap);
res++; res++;
} }

11
skein2.cpp
View File

@ -36,9 +36,10 @@ void skein2hash(void *output, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
int scanhash_skein2(int thr_id, uint32_t *pdata, const uint32_t *ptarget, int scanhash_skein2(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1 << 19); // 256*256*8 uint32_t throughput = device_intensity(thr_id, __func__, 1 << 19); // 256*256*8
@ -88,9 +89,15 @@ int scanhash_skein2(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) { if (vhash64[7] <= ptarget[7] && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
if (!opt_quiet) if (!opt_quiet)
applog(LOG_BLUE, "GPU #%d: found second nonce %08x !", device_map[thr_id], swab32(secNonce)); applog(LOG_BLUE, "GPU #%d: found second nonce %08x !", device_map[thr_id], swab32(secNonce));
endiandata[19] = secNonce;
skein2hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = swab32(secNonce); pdata[21] = swab32(secNonce);
res++; res++;
} }

16
sph/sha2.c
View File

@ -469,7 +469,7 @@ void sha256d_ms_4way(uint32_t *hash, uint32_t *data,
const uint32_t *midstate, const uint32_t *prehash); const uint32_t *midstate, const uint32_t *prehash);
static inline int scanhash_sha256d_4way(int thr_id, uint32_t *pdata, static inline int scanhash_sha256d_4way(int thr_id, uint32_t *pdata,
const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done) const uint32_t *ptarget uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t data[4 * 64] __attribute__((aligned(128))); uint32_t data[4 * 64] __attribute__((aligned(128)));
uint32_t hash[4 * 8] __attribute__((aligned(32))); uint32_t hash[4 * 8] __attribute__((aligned(32)));
@ -508,6 +508,7 @@ static inline int scanhash_sha256d_4way(int thr_id, uint32_t *pdata,
pdata[19] = data[4 * 3 + i]; pdata[19] = data[4 * 3 + i];
sha256d_80_swap(hash, pdata); sha256d_80_swap(hash, pdata);
if (fulltest(hash, ptarget)) { if (fulltest(hash, ptarget)) {
bn_store_hash_target_ratio(hash, ptarget, work);
*hashes_done = n - first_nonce + 1; *hashes_done = n - first_nonce + 1;
return 1; return 1;
} }
@ -581,13 +582,14 @@ static inline int scanhash_sha256d_8way(int thr_id, uint32_t *pdata,
#endif /* HAVE_SHA256_8WAY */ #endif /* HAVE_SHA256_8WAY */
int scanhash_sha256d(int thr_id, uint32_t *pdata, const uint32_t *ptarget, int scanhash_sha256d(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t data[64] /* __attribute__((aligned(128))) */; uint32_t _ALIGN(128) data[64];
uint32_t hash[8] /* __attribute__((aligned(32))) */; uint32_t hash[8];
uint32_t midstate[8] /* __attribute__((aligned(32))) */; uint32_t midstate[8];
uint32_t prehash[8] /* __attribute__((aligned(32))) */; uint32_t prehash[8];
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
uint32_t n = pdata[19] - 1; uint32_t n = pdata[19] - 1;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
const uint32_t Htarg = ptarget[7]; const uint32_t Htarg = ptarget[7];

12
x11/c11.cu
View File

@ -142,8 +142,10 @@ extern "C" void c11hash(void *output, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_c11(int thr_id, uint32_t *pdata, const uint32_t *ptarget, uint32_t max_nonce, unsigned long *hashes_done) extern "C" int scanhash_c11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
int intensity = (device_sm[device_map[thr_id]] >= 500 && !is_windows()) ? 20 : 19; int intensity = (device_sm[device_map[thr_id]] >= 500 && !is_windows()) ? 20 : 19;
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); // 19=256*256*8; uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); // 19=256*256*8;
@ -208,6 +210,8 @@ extern "C" int scanhash_c11(int thr_id, uint32_t *pdata, const uint32_t *ptarget
x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x11_echo512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
TRACE("echo => "); TRACE("echo => ");
*hashes_done = pdata[19] - first_nonce + throughput;
foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
{ {
@ -220,8 +224,12 @@ extern "C" int scanhash_c11(int thr_id, uint32_t *pdata, const uint32_t *ptarget
int res = 1; int res = 1;
// check if there was some other ones... // check if there was some other ones...
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
c11hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

13
x11/fresh.cu
View File

@ -70,10 +70,10 @@ extern "C" void fresh_hash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_fresh(int thr_id, uint32_t *pdata, extern "C" int scanhash_fresh(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t endiandata[20]; uint32_t endiandata[20];
@ -122,6 +122,7 @@ extern "C" int scanhash_fresh(int thr_id, uint32_t *pdata,
CUDA_SAFE_CALL(cudaThreadSynchronize()); CUDA_SAFE_CALL(cudaThreadSynchronize());
print_hash((unsigned char*)buf); printf("\n"); print_hash((unsigned char*)buf); printf("\n");
#endif #endif
*hashes_done = pdata[19] - first_nonce + throughput;
foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
@ -133,8 +134,12 @@ extern "C" int scanhash_fresh(int thr_id, uint32_t *pdata,
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) { if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
fresh_hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

14
x11/s3.cu
View File

@ -52,10 +52,10 @@ extern "C" void s3hash(void *output, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
/* Main S3 entry point */ /* Main S3 entry point */
extern "C" int scanhash_s3(int thr_id, uint32_t *pdata, extern "C" int scanhash_s3(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
int intensity = 20; // 256*256*8*2; int intensity = 20; // 256*256*8*2;
#ifdef WIN32 #ifdef WIN32
@ -99,6 +99,8 @@ extern "C" int scanhash_s3(int thr_id, uint32_t *pdata,
x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + throughput;
foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
@ -110,8 +112,12 @@ extern "C" int scanhash_s3(int thr_id, uint32_t *pdata,
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) { if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
s3hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

11
x11/x11.cu
View File

@ -142,10 +142,10 @@ extern "C" void x11hash(void *output, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_x11(int thr_id, uint32_t *pdata, extern "C" int scanhash_x11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
int intensity = (device_sm[device_map[thr_id]] >= 500 && !is_windows()) ? 20 : 19; int intensity = (device_sm[device_map[thr_id]] >= 500 && !is_windows()) ? 20 : 19;
uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); // 19=256*256*8; uint32_t throughput = device_intensity(thr_id, __func__, 1U << intensity); // 19=256*256*8;
@ -222,8 +222,13 @@ extern "C" int scanhash_x11(int thr_id, uint32_t *pdata,
int res = 1; int res = 1;
// check if there was some other ones... // check if there was some other ones...
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
bn_store_hash_target_ratio(vhash64, ptarget, work);
*hashes_done = pdata[19] - first_nonce + throughput; *hashes_done = pdata[19] - first_nonce + throughput;
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
x11hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

25
x13/x13.cu
View File

@ -145,10 +145,10 @@ extern "C" void x13hash(void *output, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_x13(int thr_id, uint32_t *pdata, extern "C" int scanhash_x13(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
int intensity = 19; // (device_sm[device_map[thr_id]] > 500 && !is_windows()) ? 20 : 19; int intensity = 19; // (device_sm[device_map[thr_id]] > 500 && !is_windows()) ? 20 : 19;
uint32_t throughput = device_intensity(thr_id, __func__, 1 << intensity); // 19=256*256*8; uint32_t throughput = device_intensity(thr_id, __func__, 1 << intensity); // 19=256*256*8;
@ -207,23 +207,30 @@ extern "C" int scanhash_x13(int thr_id, uint32_t *pdata,
x13_hamsi512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x13_hamsi512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
x13_fugue512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x13_fugue512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + throughput;
foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
{ {
const uint32_t Htarg = ptarget[7]; uint32_t vhash[8];
uint32_t vhash64[8];
be32enc(&endiandata[19], foundNonce); be32enc(&endiandata[19], foundNonce);
x13hash(vhash64, endiandata); x13hash(vhash, endiandata);
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) { if (vhash[7] <= ptarget[7] && fulltest(vhash, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash, ptarget, work);
pdata[19] = foundNonce;
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
x13hash(vhash, endiandata);
pdata[21] = secNonce; pdata[21] = secNonce;
if (bn_hash_target_ratio(vhash, ptarget) > work->shareratio) {
bn_store_hash_target_ratio(vhash, ptarget, work);
xchg(pdata[19], pdata[21]);
}
res++; res++;
} }
pdata[19] = foundNonce;
return res; return res;
} else { } else {
applog(LOG_WARNING, "GPU #%d: result for %08x does not validate on CPU!", device_map[thr_id], foundNonce); applog(LOG_WARNING, "GPU #%d: result for %08x does not validate on CPU!", device_map[thr_id], foundNonce);

10
x15/whirlpoolx.cu
View File

@ -37,9 +37,10 @@ extern "C" void whirlxHash(void *state, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_whirlpoolx(int thr_id, uint32_t *pdata, const uint32_t *ptarget, extern "C" int scanhash_whirlx(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
uint32_t max_nonce, unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t endiandata[20]; uint32_t endiandata[20];
int intensity = is_windows() ? 20 : 22; int intensity = is_windows() ? 20 : 22;
@ -65,6 +66,7 @@ extern "C" int scanhash_whirlpoolx(int thr_id, uint32_t *pdata, const uint32_t *
whirlpoolx_setBlock_80((void*)endiandata, ptarget); whirlpoolx_setBlock_80((void*)endiandata, ptarget);
whirlpoolx_precompute(thr_id); whirlpoolx_precompute(thr_id);
do { do {
uint32_t foundNonce = whirlpoolx_cpu_hash(thr_id, throughput, pdata[19]); uint32_t foundNonce = whirlpoolx_cpu_hash(thr_id, throughput, pdata[19]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
@ -74,8 +76,10 @@ extern "C" int scanhash_whirlpoolx(int thr_id, uint32_t *pdata, const uint32_t *
be32enc(&endiandata[19], foundNonce); be32enc(&endiandata[19], foundNonce);
whirlxHash(vhash64, endiandata); whirlxHash(vhash64, endiandata);
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
*hashes_done = pdata[19] - first_nonce + throughput; *hashes_done = pdata[19] - first_nonce + throughput;
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[19] = foundNonce; pdata[19] = foundNonce;
return 1; return 1;
} else { } else {

14
x15/x14.cu
View File

@ -157,10 +157,10 @@ extern "C" void x14hash(void *output, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_x14(int thr_id, uint32_t *pdata, extern "C" int scanhash_x14(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t endiandata[20]; uint32_t endiandata[20];
@ -216,6 +216,8 @@ extern "C" int scanhash_x14(int thr_id, uint32_t *pdata,
x13_fugue512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x13_fugue512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
x14_shabal512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x14_shabal512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + throughput;
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
{ {
@ -228,8 +230,12 @@ extern "C" int scanhash_x14(int thr_id, uint32_t *pdata,
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) { if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
x14hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

14
x15/x15.cu
View File

@ -167,10 +167,10 @@ extern "C" void x15hash(void *output, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_x15(int thr_id, uint32_t *pdata, extern "C" int scanhash_x15(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t endiandata[20]; uint32_t endiandata[20];
@ -228,6 +228,8 @@ extern "C" int scanhash_x15(int thr_id, uint32_t *pdata,
x14_shabal512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x14_shabal512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
x15_whirlpool_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x15_whirlpool_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + throughput;
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
{ {
@ -240,8 +242,12 @@ extern "C" int scanhash_x15(int thr_id, uint32_t *pdata,
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) { if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
x15hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }

14
x17/x17.cu
View File

@ -186,10 +186,10 @@ extern "C" void x17hash(void *output, const void *input)
static bool init[MAX_GPUS] = { 0 }; static bool init[MAX_GPUS] = { 0 };
extern "C" int scanhash_x17(int thr_id, uint32_t *pdata, extern "C" int scanhash_x17(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done)
const uint32_t *ptarget, uint32_t max_nonce,
unsigned long *hashes_done)
{ {
uint32_t *pdata = work->data;
uint32_t *ptarget = work->target;
const uint32_t first_nonce = pdata[19]; const uint32_t first_nonce = pdata[19];
uint32_t throughput = device_intensity(thr_id, __func__, 1U << 19); // 19=256*256*8; uint32_t throughput = device_intensity(thr_id, __func__, 1U << 19); // 19=256*256*8;
@ -254,6 +254,8 @@ extern "C" int scanhash_x17(int thr_id, uint32_t *pdata,
x17_sha512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x17_sha512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
x17_haval256_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++); x17_haval256_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
*hashes_done = pdata[19] - first_nonce + throughput;
uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]); uint32_t foundNonce = cuda_check_hash(thr_id, throughput, pdata[19], d_hash[thr_id]);
if (foundNonce != UINT32_MAX) if (foundNonce != UINT32_MAX)
{ {
@ -265,8 +267,12 @@ extern "C" int scanhash_x17(int thr_id, uint32_t *pdata,
if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) { if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
int res = 1; int res = 1;
uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1); uint32_t secNonce = cuda_check_hash_suppl(thr_id, throughput, pdata[19], d_hash[thr_id], 1);
*hashes_done = pdata[19] - first_nonce + throughput; bn_store_hash_target_ratio(vhash64, ptarget, work);
if (secNonce != 0) { if (secNonce != 0) {
be32enc(&endiandata[19], secNonce);
x17hash(vhash64, endiandata);
if (bn_hash_target_ratio(vhash64, ptarget) > work->shareratio)
bn_store_hash_target_ratio(vhash64, ptarget, work);
pdata[21] = secNonce; pdata[21] = secNonce;
res++; res++;
} }