int scanhash_m7m_hash(int thr_id, uint32_t *pdata, const uint32_t *ptarget,
uint64_t max_nonce, unsigned long *hashes_done)
{
uint32_t data[32] __attribute__((aligned(128)));
uint32_t *data_p64 = data + (M7_MIDSTATE_LEN / sizeof(data[0]));
uint32_t hash[8] __attribute__((aligned(32)));
uint8_t bhash[7][64] __attribute__((aligned(32)));
uint32_t n = pdata[19] - 1;
const uint32_t first_nonce = pdata[19];
char data_str[161], hash_str[65], target_str[65];
uint8_t *bdata = 0;
mpz_t bns[8];
int rc = 0;
int bytes, nnNonce2;
mpz_t product;
mpz_init(product);
for(int i=0; i < 8; i++){
mpz_init(bns[i]);
}
memcpy(data, pdata, 80);
sph_sha256_context ctx_final_sha256;
sph_sha256_context ctx_sha256;
sph_sha512_context ctx_sha512;
sph_keccak512_context ctx_keccak;
sph_whirlpool_context ctx_whirlpool;
sph_haval256_5_context ctx_haval;
sph_tiger_context ctx_tiger;
sph_ripemd160_context ctx_ripemd;
sph_sha256_init(&ctx_sha256);
sph_sha256 (&ctx_sha256, data, M7_MIDSTATE_LEN);
sph_sha512_init(&ctx_sha512);
sph_sha512 (&ctx_sha512, data, M7_MIDSTATE_LEN);
sph_keccak512_init(&ctx_keccak);
sph_keccak512 (&ctx_keccak, data, M7_MIDSTATE_LEN);
sph_whirlpool_init(&ctx_whirlpool);
sph_whirlpool (&ctx_whirlpool, data, M7_MIDSTATE_LEN);
sph_haval256_5_init(&ctx_haval);
sph_haval256_5 (&ctx_haval, data, M7_MIDSTATE_LEN);
sph_tiger_init(&ctx_tiger);
sph_tiger (&ctx_tiger, data, M7_MIDSTATE_LEN);
sph_ripemd160_init(&ctx_ripemd);
sph_ripemd160 (&ctx_ripemd, data, M7_MIDSTATE_LEN);
sph_sha256_context ctx2_sha256;
sph_sha512_context ctx2_sha512;
sph_keccak512_context ctx2_keccak;
sph_whirlpool_context ctx2_whirlpool;
sph_haval256_5_context ctx2_haval;
sph_tiger_context ctx2_tiger;
sph_ripemd160_context ctx2_ripemd;
do {
data[19] = ++n;
nnNonce2 = (int)(data[19]/2);
memset(bhash, 0, 7 * 64);
ctx2_sha256 = ctx_sha256;
sph_sha256 (&ctx2_sha256, data_p64, 80 - M7_MIDSTATE_LEN);
sph_sha256_close(&ctx2_sha256, (void*)(bhash[0]));
ctx2_sha512 = ctx_sha512;
sph_sha512 (&ctx2_sha512, data_p64, 80 - M7_MIDSTATE_LEN);
sph_sha512_close(&ctx2_sha512, (void*)(bhash[1]));
ctx2_keccak = ctx_keccak;
sph_keccak512 (&ctx2_keccak, data_p64, 80 - M7_MIDSTATE_LEN);
sph_keccak512_close(&ctx2_keccak, (void*)(bhash[2]));
ctx2_whirlpool = ctx_whirlpool;
sph_whirlpool (&ctx2_whirlpool, data_p64, 80 - M7_MIDSTATE_LEN);
sph_whirlpool_close(&ctx2_whirlpool, (void*)(bhash[3]));
ctx2_haval = ctx_haval;
sph_haval256_5 (&ctx2_haval, data_p64, 80 - M7_MIDSTATE_LEN);
sph_haval256_5_close(&ctx2_haval, (void*)(bhash[4]));
ctx2_tiger = ctx_tiger;
sph_tiger (&ctx2_tiger, data_p64, 80 - M7_MIDSTATE_LEN);
sph_tiger_close(&ctx2_tiger, (void*)(bhash[5]));
ctx2_ripemd = ctx_ripemd;
sph_ripemd160 (&ctx2_ripemd, data_p64, 80 - M7_MIDSTATE_LEN);
sph_ripemd160_close(&ctx2_ripemd, (void*)(bhash[6]));
for(int i=0; i < 7; i++){
set_one_if_zero(bhash[i]);
mpz_set_uint512(bns[i],bhash[i]);
}
mpz_set_ui(bns[7],0);
for(int i=0; i < 7; i++){
mpz_add(bns[7], bns[7], bns[i]);
}
mpz_set_ui(product,1);
for(int i=0; i < 8; i++){
mpz_mul(product,product,bns[i]);
}
mpz_pow_ui(product, product, 2);
bytes = mpz_sizeinbase(product, 256);
bdata = (uint8_t *)realloc(bdata, bytes);
mpz_export((void *)bdata, NULL, -1, 1, 0, 0, product);
sph_sha256_init(&ctx_final_sha256);
sph_sha256 (&ctx_final_sha256, bdata, bytes);
sph_sha256_close(&ctx_final_sha256, (void*)(hash));
int digits=(int)((sqrt((double)(nnNonce2))*(1.+EPS))/9000+75);
int iterations=20;
mpf_set_default_prec((long int)(digits*BITS_PER_DIGIT+16));
mpz_t magipi;
mpz_t magisw;
mpf_t magifpi;
mpf_t mpa1, mpb1, mpt1, mpp1;
mpf_t mpa2, mpb2, mpt2, mpp2;
mpf_t mpsft;
mpz_init(magipi);
mpz_init(magisw);
mpf_init(magifpi);
mpf_init(mpsft);
mpf_init(mpa1);
mpf_init(mpb1);
mpf_init(mpt1);
mpf_init(mpp1);
mpf_init(mpa2);
mpf_init(mpb2);
mpf_init(mpt2);
mpf_init(mpp2);
uint32_t usw_;
usw_ = sw_(nnNonce2, SW_DIVS);
if (usw_ < 1) usw_ = 1;
mpz_set_ui(magisw, usw_);
uint32_t mpzscale=mpz_size(magisw);
for(int i=0; i < NM7M; i++){
if (mpzscale > 1000) {
mpzscale = 1000;
}
else if (mpzscale < 1) {
mpzscale = 1;
}
mpf_set_ui(mpa1, 1);
mpf_set_ui(mpb1, 2);
mpf_set_d(mpt1, 0.25*mpzscale);
mpf_set_ui(mpp1, 1);
mpf_sqrt(mpb1, mpb1);
mpf_ui_div(mpb1, 1, mpb1);
mpf_set_ui(mpsft, 10);
for(int j=0; j <= iterations; j++){
mpf_add(mpa2, mpa1, mpb1);
mpf_div_ui(mpa2, mpa2, 2);
mpf_mul(mpb2, mpa1, mpb1);
mpf_abs(mpb2, mpb2);
mpf_sqrt(mpb2, mpb2);
mpf_sub(mpt2, mpa1, mpa2);
mpf_abs(mpt2, mpt2);
mpf_sqrt(mpt2, mpt2);
mpf_mul(mpt2, mpt2, mpp1);
mpf_sub(mpt2, mpt1, mpt2);
mpf_mul_ui(mpp2, mpp1, 2);
mpf_swap(mpa1, mpa2);
mpf_swap(mpb1, mpb2);
mpf_swap(mpt1, mpt2);
mpf_swap(mpp1, mpp2);
}
mpf_add(magifpi, mpa1, mpb1);
mpf_pow_ui(magifpi, magifpi, 2);
mpf_div_ui(magifpi, magifpi, 4);
mpf_abs(mpt1, mpt1);
mpf_div(magifpi, magifpi, mpt1);
mpf_pow_ui(mpsft, mpsft, digits/2);
mpf_mul(magifpi, magifpi, mpsft);
mpz_set_f(magipi, magifpi);
mpz_add(product,product,magipi);
mpz_add(product,product,magisw);
mpz_set_uint256(bns[0], (void*)(hash));
mpz_add(bns[7], bns[7], bns[0]);
mpz_mul(product,product,bns[7]);
mpz_cdiv_q (product, product, bns[0]);
if (mpz_sgn(product) <= 0) mpz_set_ui(product,1);
bytes = mpz_sizeinbase(product, 256);
mpzscale=bytes;
bdata = (uint8_t *)realloc(bdata, bytes);
mpz_export(bdata, NULL, -1, 1, 0, 0, product);
sph_sha256_init(&ctx_final_sha256);
sph_sha256 (&ctx_final_sha256, bdata, bytes);
sph_sha256_close(&ctx_final_sha256, (void*)(hash));
}
mpz_clear(magipi);
mpz_clear(magisw);
mpf_clear(magifpi);
mpf_clear(mpsft);
mpf_clear(mpa1);
mpf_clear(mpb1);
mpf_clear(mpt1);
mpf_clear(mpp1);
mpf_clear(mpa2);
mpf_clear(mpb2);
mpf_clear(mpt2);
mpf_clear(mpp2);
rc = fulltest_m7hash(hash, ptarget);
if (rc) {
if (opt_debug) {
bin2hex(hash_str, (unsigned char *)hash, 32);
bin2hex(target_str, (unsigned char *)ptarget, 32);
bin2hex(data_str, (unsigned char *)data, 80);
applog(LOG_DEBUG, "DEBUG: [%d thread] Found share!\ndata %s\nhash %s\ntarget %s", thr_id,
data_str,
hash_str,
target_str);
}
pdata[19] = data[19];
goto out;
}
} while (n < max_nonce && !work_restart[thr_id].restart);
pdata[19] = n;
out:
for(int i=0; i < 8; i++){
mpz_clear(bns[i]);
}
mpz_clear(product);
free(bdata);
*hashes_done = n - first_nonce + 1;
return rc;
}
void BitcoinMiner(primecoinBlock_t* primecoinBlock, sint32 threadIndex)
{
//printf("PrimecoinMiner started\n");
//SetThreadPriority(THREAD_PRIORITY_LOWEST);
//RenameThread("primecoin-miner");
if( pctx == NULL )
pctx = BN_CTX_new();
// Each thread has its own key and counter
//CReserveKey reservekey(pwallet);
unsigned int nExtraNonce = 0;
static const unsigned int nPrimorialHashFactor = 7;
unsigned int nPrimorialMultiplierStart = 7;
static int startFactorList[4] =
{
107,107,107,107
//131,131,131,131
};
// there is a much better way to do all the primorial and fixedMutliplier calculation, but this has to suffice for now...
nPrimorialMultiplierStart = startFactorList[(threadIndex&3)];
unsigned int nPrimorialMultiplier = nPrimorialMultiplierStart;
int64 nTimeExpected = 0; // time expected to prime chain (micro-second)
int64 nTimeExpectedPrev = 0; // time expected to prime chain last time
bool fIncrementPrimorial = true; // increase or decrease primorial factor
CSieveOfEratosthenes* psieve = NULL;
primecoinBlock->nonce = 0;
//uint32 nTime = GetTickCount() + 1000*60;
// note: originally a wanted to loop as long as (primecoinBlock->workDataHash != jhMiner_getCurrentWorkHash()) did not happen
// but I noticed it might be smarter to just check if the blockHeight has changed, since that is what is really important
nPrimorialMultiplier = nPrimorialMultiplierStart;
uint32 loopCount = 0;
mpz_class bnHashFactor;
Primorial(nPrimorialHashFactor, bnHashFactor);
time_t unixTimeStart;
time(&unixTimeStart);
uint32 nTimeRollStart = primecoinBlock->timestamp;
while( primecoinBlock->serverData.blockHeight == jhMiner_getCurrentWorkBlockHeight(primecoinBlock->threadIndex) )
{
if( primecoinBlock->xptMode )
{
// when using x.pushthrough, roll time
time_t unixTimeCurrent;
time(&unixTimeCurrent);
uint32 timeDif = unixTimeCurrent - unixTimeStart;
uint32 newTimestamp = nTimeRollStart + timeDif;
if( newTimestamp != primecoinBlock->timestamp )
{
primecoinBlock->timestamp = newTimestamp;
primecoinBlock->nonce = 0;
nPrimorialMultiplierStart = startFactorList[(threadIndex&3)];
}
}
primecoinBlock_generateHeaderHash(primecoinBlock, primecoinBlock->blockHeaderHash.begin());
//
// Search
//
bool fNewBlock = true;
unsigned int nTriedMultiplier = 0;
uint256 phash = primecoinBlock->blockHeaderHash;
mpz_class mpzHash;
mpz_set_uint256(mpzHash.get_mpz_t(), phash);
// Primecoin: try to find hash divisible by primorial
while ((phash < hashBlockHeaderLimit || (mpzHash % bnHashFactor != 0)) && primecoinBlock->nonce < 0xffff0000)
{
primecoinBlock->nonce++;
primecoinBlock_generateHeaderHash(primecoinBlock, primecoinBlock->blockHeaderHash.begin());
phash = primecoinBlock->blockHeaderHash;
mpz_set_uint256(mpzHash.get_mpz_t(), phash);
}
//printf("Use nonce %d\n", primecoinBlock->nonce);
if (primecoinBlock->nonce >= 0xffff0000)
{
printf("Nonce overflow\n");
break;
}
// Primecoin: primorial fixed multiplier
mpz_class bnPrimorial;
unsigned int nRoundTests = 0;
unsigned int nRoundPrimesHit = 0;
//int64 nPrimeTimerStart = GetTimeMicros();
//if (nTimeExpected > nTimeExpectedPrev)
// fIncrementPrimorial = !fIncrementPrimorial;
//nTimeExpectedPrev = nTimeExpected;
//// Primecoin: dynamic adjustment of primorial multiplier
//if (fIncrementPrimorial)
//{
// if (!PrimeTableGetNextPrime(&nPrimorialMultiplier))
// error("PrimecoinMiner() : primorial increment overflow");
//}
//else if (nPrimorialMultiplier > nPrimorialHashFactor)
//{
// if (!PrimeTableGetPreviousPrime(&nPrimorialMultiplier))
// error("PrimecoinMiner() : primorial decrement overflow");
//}
//if( loopCount > 0 )
//{
// primecoinBlock->nonce++;
///* if (!PrimeTableGetNextPrime(&nPrimorialMultiplier))
// error("PrimecoinMiner() : primorial increment overflow");*/
//}
Primorial(nPrimorialMultiplier, bnPrimorial);
unsigned int nTests = 0;
unsigned int nPrimesHit = 0;
mpz_class bnMultiplierMin = bnPrimeMin * bnHashFactor / mpzHash + 2;
while (bnPrimorial < bnMultiplierMin )
{
if (!PrimeTableGetNextPrime(&nPrimorialMultiplier))
error("PrimecoinMiner() : primorial minimum overflow");
Primorial(nPrimorialMultiplier, bnPrimorial);
}
mpz_class bnFixedMultiplier;
if(bnPrimorial > bnHashFactor){
bnFixedMultiplier = bnPrimorial / bnHashFactor;
}else{
bnFixedMultiplier = 1;
}
//printf("fixedMultiplier: %d nPrimorialMultiplier: %d\n", BN_get_word(&bnFixedMultiplier), nPrimorialMultiplier);
// Primecoin: mine for prime chain
unsigned int nProbableChainLength;
if (MineProbablePrimeChain(&psieve, primecoinBlock, bnFixedMultiplier, fNewBlock, nTriedMultiplier, nProbableChainLength, nTests, nPrimesHit))
{
// do nothing here, share is already submitted in MineProbablePrimeChain()
break;
}
//psieve = NULL;
nRoundTests += nTests;
nRoundPrimesHit += nPrimesHit;
// added this
/*if( nPrimorialMultiplier >= 800 )
{
primecoinBlock->nonce++;
nPrimorialMultiplier = nPrimorialMultiplierStart;
}*/
//if( nPrimorialMultiplier >= 800 )
//{
// primecoinBlock->nonce++;
// nPrimorialMultiplier = nPrimorialMultiplierStart;
//}
//if( primecoinBlock->nonce >= 0x100 )
//{
// printf("Base reset\n");
// primecoinBlock->nonce = 0;
// nPrimorialMultiplier = nPrimorialMultiplierStart;
//}
primecoinBlock->nonce++;
loopCount++;
}
}
bool BitcoinMiner(primecoinBlock_t* primecoinBlock, CSieveOfEratosthenes*& psieve, const sint32 threadIndex, const unsigned int nonceStep)
{
//JLR DBG
//printf("PrimecoinMiner started\n");
//SetThreadPriority(THREAD_PRIORITY_LOWEST);
//RenameThread("primecoin-miner");
if( pctx == NULL )
pctx = BN_CTX_new();
// Each thread has its own key and counter
//CReserveKey reservekey(pwallet);
// unsigned int nExtraNonce = 0; unused?
static const unsigned int MAX_NONCE = 0xFFFF0000; // From Primecoind sources.
static const unsigned int nPrimorialHashFactor = 7;
// const unsigned int nPrimorialMultiplierStart = 61; unused?
// const unsigned int nPrimorialMultiplierMax = 79; unused?
unsigned int nPrimorialMultiplier = primeStats.nPrimorialMultiplier;
// uint64_t nTimeExpected = 0; // time expected to prime chain (micro-second) unused?
// uint64_t nTimeExpectedPrev = 0; // time expected to prime chain last time unused?
// bool fIncrementPrimorial = true; // increase or decrease primorial factor unused?
// uint64_t nSieveGenTime = 0; unused?
// Generate a thread specific nonce.
primecoinBlock->nonce = threadIndex;
uint64 nTime = getTimeMilliseconds() + 1000*600;
// uint64 nStatTime = getTimeMilliseconds() + 2000; unused?
// note: originally a wanted to loop as long as (primecoinBlock->workDataHash != jhMiner_getCurrentWorkHash()) did not happen
// but I noticed it might be smarter to just check if the blockHeight has changed, since that is what is really important
uint32 loopCount = 0;
//mpz_class mpzHashFactor;
//Primorial(nPrimorialHashFactor, mpzHashFactor);
unsigned int nHashFactor = PrimorialFast(nPrimorialHashFactor);
time_t unixTimeStart;
time(&unixTimeStart);
uint32 nTimeRollStart = primecoinBlock->timestamp - 5;
uint32 nLastRollTime = getTimeMilliseconds();
uint32 nCurrentTick = nLastRollTime;
while( nCurrentTick < nTime && primecoinBlock->serverData.blockHeight == jhMiner_getCurrentWorkBlockHeight(primecoinBlock->threadIndex) )
{
nCurrentTick = getTimeMilliseconds();
// Roll Time stamp every 10 secs.
if ((primecoinBlock->xptMode) && (nCurrentTick < nLastRollTime || (nLastRollTime - nCurrentTick >= 10000)))
{
// when using x.pushthrough, roll time
time_t unixTimeCurrent;
time(&unixTimeCurrent);
uint32 timeDif = unixTimeCurrent - unixTimeStart;
uint32 newTimestamp = nTimeRollStart + timeDif;
if( newTimestamp != primecoinBlock->timestamp )
{
primecoinBlock->timestamp = newTimestamp;
primecoinBlock->nonce = threadIndex;
//nPrimorialMultiplierStart = startFactorList[(threadIndex&3)];
//nPrimorialMultiplier = nPrimorialMultiplierStart;
}
nLastRollTime = nCurrentTick;
}
primecoinBlock_generateHeaderHash(primecoinBlock, primecoinBlock->blockHeaderHash.begin());
//
// Search
//
bool fNewBlock = true;
unsigned int nTriedMultiplier = 0;
// Primecoin: try to find hash divisible by primorial
uint256 phash = primecoinBlock->blockHeaderHash;
mpz_class mpzHash;
mpz_set_uint256(mpzHash.get_mpz_t(), phash);
while ((phash < hashBlockHeaderLimit || !mpz_divisible_ui_p(mpzHash.get_mpz_t(), nHashFactor)) && primecoinBlock->nonce < MAX_NONCE) {
primecoinBlock->nonce += nonceStep;
primecoinBlock_generateHeaderHash(primecoinBlock, primecoinBlock->blockHeaderHash.begin());
phash = primecoinBlock->blockHeaderHash;
mpz_set_uint256(mpzHash.get_mpz_t(), phash);
}
//JLR DBG
//printf("Use nonce %d\n", primecoinBlock->nonce);
if (primecoinBlock->nonce >= MAX_NONCE)
{
//JLR DBG
printf("Nonce overflow\n");
break;
}
// Primecoin: primorial fixed multiplier
mpz_class mpzPrimorial;
unsigned int nRoundTests = 0;
unsigned int nRoundPrimesHit = 0;
// uint64 nPrimeTimerStart = getTimeMilliseconds(); unused?
//if( loopCount > 0 )
//{
// //primecoinBlock->nonce++;
// if (!PrimeTableGetNextPrime(nPrimorialMultiplier))
// error("PrimecoinMiner() : primorial increment overflow");
//}
Primorial(nPrimorialMultiplier, mpzPrimorial);
unsigned int nTests = 0;
unsigned int nPrimesHit = 0;
mpz_class mpzMultiplierMin = mpzPrimeMin * nHashFactor / mpzHash + 1;
while (mpzPrimorial < mpzMultiplierMin )
{
if (!PrimeTableGetNextPrime(nPrimorialMultiplier))
error("PrimecoinMiner() : primorial minimum overflow");
Primorial(nPrimorialMultiplier, mpzPrimorial);
}
mpz_class mpzFixedMultiplier;
if (mpzPrimorial > nHashFactor) {
mpzFixedMultiplier = mpzPrimorial / nHashFactor;
} else {
mpzFixedMultiplier = 1;
}
//JLR DBG
//printf("fixedMultiplier: %d nPrimorialMultiplier: %d\n", BN_get_word(&bnFixedMultiplier), nPrimorialMultiplier);
// Primecoin: mine for prime chain
unsigned int nProbableChainLength;
MineProbablePrimeChain(psieve, primecoinBlock, mpzFixedMultiplier, fNewBlock, nTriedMultiplier, nProbableChainLength, nTests, nPrimesHit, threadIndex, mpzHash, nPrimorialMultiplier);
#ifdef _WIN32
threadHearthBeat[threadIndex] = getTimeMilliseconds();
#endif
if (appQuitSignal)
{
printf( "Shutting down mining thread %d.\n", threadIndex);
return false;
}
//{
// // do nothing here, share is already submitted in MineProbablePrimeChain()
// //primecoinBlock->nonce += 0x00010000;
// primecoinBlock->nonce++;
// nPrimorialMultiplier = primeStats.nPrimorialMultiplier;
// //break;
//}
//psieve = NULL;
nRoundTests += nTests;
nRoundPrimesHit += nPrimesHit;
nPrimorialMultiplier = primeStats.nPrimorialMultiplier;
// added this
//if (fNewBlock)
//{
//}
primecoinBlock->nonce += nonceStep;
//primecoinBlock->timestamp = max(primecoinBlock->timestamp, (unsigned int) time(NULL));
loopCount++;
}
return true;
}
bool BitcoinMiner(primecoinBlock_t* primecoinBlock, CSieveOfEratosthenes*& psieve, unsigned int threadIndex, unsigned int nonceStep) {
if (pctx == NULL) { pctx = BN_CTX_new(); }
primecoinBlock->nonce = 1+threadIndex;
const unsigned long maxNonce = 0xFFFFFFFF;
uint32 nTime = getTimeMilliseconds() + 1000*600;
uint32 loopCount = 0;
mpz_class mpzHashFactor = 2310; //11 Hash Factor
time_t unixTimeStart;
time(&unixTimeStart);
uint32 nTimeRollStart = primecoinBlock->timestamp - 5;
uint32 nLastRollTime = getTimeMilliseconds();
uint32 nCurrentTick = nLastRollTime;
while( nCurrentTick < nTime && primecoinBlock->serverData.blockHeight == jhMiner_getCurrentWorkBlockHeight(primecoinBlock->threadIndex) )
{
nCurrentTick = getTimeMilliseconds();
// Roll Time stamp every 10 secs.
if ((primecoinBlock->xptMode) && (nCurrentTick < nLastRollTime || (nLastRollTime - nCurrentTick >= 10000)))
{
// when using x.pushthrough, roll time
time_t unixTimeCurrent;
time(&unixTimeCurrent);
uint32 timeDif = unixTimeCurrent - unixTimeStart;
uint32 newTimestamp = nTimeRollStart + timeDif;
if( newTimestamp != primecoinBlock->timestamp )
{
primecoinBlock->timestamp = newTimestamp;
primecoinBlock->nonce = 1+threadIndex;
}
nLastRollTime = nCurrentTick;
}
primecoinBlock_generateHeaderHash(primecoinBlock, primecoinBlock->blockHeaderHash.begin());
bool fNewBlock = true;
unsigned int nTriedMultiplier = 0;
// Primecoin: try to find hash divisible by primorial
uint256 phash = primecoinBlock->blockHeaderHash;
mpz_class mpzHash;
mpz_set_uint256(mpzHash.get_mpz_t(), phash);
while ((phash < hashBlockHeaderLimit || !mpz_divisible_p(mpzHash.get_mpz_t(), mpzHashFactor.get_mpz_t())) && primecoinBlock->nonce < maxNonce) {
primecoinBlock->nonce += nonceStep;
if (primecoinBlock->nonce >= maxNonce) { primecoinBlock->nonce = 2+threadIndex; }
primecoinBlock_generateHeaderHash(primecoinBlock, primecoinBlock->blockHeaderHash.begin());
phash = primecoinBlock->blockHeaderHash;
mpz_set_uint256(mpzHash.get_mpz_t(), phash);
}
mpz_class mpzPrimorial;mpz_class mpzFixedMultiplier;
unsigned int nRoundTests = 0;unsigned int nRoundPrimesHit = 0;
unsigned int nTests = 0;unsigned int nPrimesHit = 0;
unsigned int nProbableChainLength;
if (primeStats.tSplit) {
unsigned int nPrimorialMultiplier = primeStats.nPrimorials[threadIndex%primeStats.nPrimorialsSize];
Primorial(nPrimorialMultiplier, mpzPrimorial);
mpzFixedMultiplier = mpzPrimorial / mpzHashFactor;
MineProbablePrimeChain(psieve, primecoinBlock, mpzFixedMultiplier, fNewBlock, nTriedMultiplier, nProbableChainLength, nTests, nPrimesHit, threadIndex, mpzHash, nPrimorialMultiplier);
} else {
unsigned int nPrimorialMultiplier = primeStats.nPrimorials[threadSNum];
Primorial(nPrimorialMultiplier, mpzPrimorial);
mpzFixedMultiplier = mpzPrimorial / mpzHashFactor;
MineProbablePrimeChain(psieve, primecoinBlock, mpzFixedMultiplier, fNewBlock, nTriedMultiplier, nProbableChainLength, nTests, nPrimesHit, threadIndex, mpzHash, nPrimorialMultiplier);
threadSNum++;if (threadSNum>=primeStats.nPrimorialsSize) { threadSNum = 0; }
#ifdef _WIN32
threadHearthBeat[threadIndex] = getTimeMilliseconds();
#endif
if (appQuitSignal)
{
printf( "Shutting down mining thread %d.\n", threadIndex);
return false;
}
}
if (appQuitSignal) { printf( "Shutting down mining thread %d.\n", threadIndex);return false; }
nRoundTests += nTests;
nRoundPrimesHit += nPrimesHit;
primecoinBlock->nonce += nonceStep;
loopCount++;
}
return true;
}
//#define SW_MAX 1000
void m7magi_hash(const char* input, char* output)
{
unsigned int nnNonce;
uint32_t pdata[32];
memcpy(pdata, input, 80);
// memcpy(&nnNonce, input+76, 4);
int i, j, bytes, nnNonce2;
nnNonce2 = (int)(pdata[19]/2);
size_t sz = 80;
uint8_t bhash[7][64];
uint32_t hash[8];
memset(bhash, 0, 7 * 64);
sph_sha256_context ctx_final_sha256;
sph_sha256_context ctx_sha256;
sph_sha512_context ctx_sha512;
sph_keccak512_context ctx_keccak;
sph_whirlpool_context ctx_whirlpool;
sph_haval256_5_context ctx_haval;
sph_tiger_context ctx_tiger;
sph_ripemd160_context ctx_ripemd;
sph_sha256_init(&ctx_sha256);
// ZSHA256;
sph_sha256 (&ctx_sha256, input, sz);
sph_sha256_close(&ctx_sha256, (void*)(bhash[0]));
sph_sha512_init(&ctx_sha512);
// ZSHA512;
sph_sha512 (&ctx_sha512, input, sz);
sph_sha512_close(&ctx_sha512, (void*)(bhash[1]));
sph_keccak512_init(&ctx_keccak);
// ZKECCAK;
sph_keccak512 (&ctx_keccak, input, sz);
sph_keccak512_close(&ctx_keccak, (void*)(bhash[2]));
sph_whirlpool_init(&ctx_whirlpool);
// ZWHIRLPOOL;
sph_whirlpool (&ctx_whirlpool, input, sz);
sph_whirlpool_close(&ctx_whirlpool, (void*)(bhash[3]));
sph_haval256_5_init(&ctx_haval);
// ZHAVAL;
sph_haval256_5 (&ctx_haval, input, sz);
sph_haval256_5_close(&ctx_haval, (void*)(bhash[4]));
sph_tiger_init(&ctx_tiger);
// ZTIGER;
sph_tiger (&ctx_tiger, input, sz);
sph_tiger_close(&ctx_tiger, (void*)(bhash[5]));
sph_ripemd160_init(&ctx_ripemd);
// ZRIPEMD;
sph_ripemd160 (&ctx_ripemd, input, sz);
sph_ripemd160_close(&ctx_ripemd, (void*)(bhash[6]));
// printf("%s\n", hash[6].GetHex().c_str());
mpz_t bns[8];
for(i=0; i < 8; i++){
mpz_init(bns[i]);
}
//Take care of zeros and load gmp
for(i=0; i < 7; i++){
set_one_if_zero(bhash[i]);
mpz_set_uint512(bns[i],bhash[i]);
}
mpz_set_ui(bns[7],0);
for(i=0; i < 7; i++)
mpz_add(bns[7], bns[7], bns[i]);
mpz_t product;
mpz_init(product);
mpz_set_ui(product,1);
// mpz_pow_ui(bns[7], bns[7], 2);
for(i=0; i < 8; i++){
mpz_mul(product,product,bns[i]);
}
mpz_pow_ui(product, product, 2);
bytes = mpz_sizeinbase(product, 256);
// printf("M7M data space: %iB\n", bytes);
char *data = (char*)malloc(bytes);
mpz_export(data, NULL, -1, 1, 0, 0, product);
sph_sha256_init(&ctx_final_sha256);
// ZSHA256;
sph_sha256 (&ctx_final_sha256, data, bytes);
sph_sha256_close(&ctx_final_sha256, (void*)(hash));
free(data);
int digits=(int)((sqrt((double)(nnNonce2))*(1.+EPS))/9000+75);
// int iterations=(int)((sqrt((double)(nnNonce2))+EPS)/500+350); // <= 500
// int digits=100;
int iterations=20; // <= 500
mpf_set_default_prec((long int)(digits*BITS_PER_DIGIT+16));
mpz_t magipi;
mpz_t magisw;
mpf_t magifpi;
mpf_t mpa1, mpb1, mpt1, mpp1;
mpf_t mpa2, mpb2, mpt2, mpp2;
mpf_t mpsft;
mpz_init(magipi);
mpz_init(magisw);
mpf_init(magifpi);
mpf_init(mpsft);
mpf_init(mpa1);
mpf_init(mpb1);
mpf_init(mpt1);
mpf_init(mpp1);
mpf_init(mpa2);
mpf_init(mpb2);
mpf_init(mpt2);
mpf_init(mpp2);
uint32_t usw_;
usw_ = sw_(nnNonce2, SW_DIVS);
if (usw_ < 1) usw_ = 1;
// if(fDebugMagi) printf("usw_: %d\n", usw_);
mpz_set_ui(magisw, usw_);
uint32_t mpzscale=mpz_size(magisw);
for(i=0; i < NM7M; i++)
{
if (mpzscale > 1000) {
mpzscale = 1000;
}
else if (mpzscale < 1) {
mpzscale = 1;
}
// if(fDebugMagi) printf("mpzscale: %d\n", mpzscale);
mpf_set_ui(mpa1, 1);
mpf_set_ui(mpb1, 2);
mpf_set_d(mpt1, 0.25*mpzscale);
mpf_set_ui(mpp1, 1);
mpf_sqrt(mpb1, mpb1);
mpf_ui_div(mpb1, 1, mpb1);
mpf_set_ui(mpsft, 10);
for(j=0; j <= iterations; j++)
{
mpf_add(mpa2, mpa1, mpb1);
mpf_div_ui(mpa2, mpa2, 2);
mpf_mul(mpb2, mpa1, mpb1);
mpf_abs(mpb2, mpb2);
mpf_sqrt(mpb2, mpb2);
mpf_sub(mpt2, mpa1, mpa2);
mpf_abs(mpt2, mpt2);
mpf_sqrt(mpt2, mpt2);
mpf_mul(mpt2, mpt2, mpp1);
mpf_sub(mpt2, mpt1, mpt2);
mpf_mul_ui(mpp2, mpp1, 2);
mpf_swap(mpa1, mpa2);
mpf_swap(mpb1, mpb2);
mpf_swap(mpt1, mpt2);
mpf_swap(mpp1, mpp2);
}
mpf_add(magifpi, mpa1, mpb1);
mpf_pow_ui(magifpi, magifpi, 2);
mpf_div_ui(magifpi, magifpi, 4);
mpf_abs(mpt1, mpt1);
mpf_div(magifpi, magifpi, mpt1);
// mpf_out_str(stdout, 10, digits+2, magifpi);
mpf_pow_ui(mpsft, mpsft, digits/2);
mpf_mul(magifpi, magifpi, mpsft);
mpz_set_f(magipi, magifpi);
//mpz_set_ui(magipi,1);
mpz_add(product,product,magipi);
mpz_add(product,product,magisw);
mpz_set_uint256(bns[0], (void*)(hash));
mpz_add(bns[7], bns[7], bns[0]);
mpz_mul(product,product,bns[7]);
mpz_cdiv_q (product, product, bns[0]);
if (mpz_sgn(product) <= 0) mpz_set_ui(product,1);
bytes = mpz_sizeinbase(product, 256);
mpzscale=bytes;
// printf("M7M data space: %iB\n", bytes);
char *bdata = (char*)malloc(bytes);
mpz_export(bdata, NULL, -1, 1, 0, 0, product);
sph_sha256_init(&ctx_final_sha256);
// ZSHA256;
sph_sha256 (&ctx_final_sha256, bdata, bytes);
sph_sha256_close(&ctx_final_sha256, (void*)(hash));
free(bdata);
}
//Free the memory
for(i=0; i < 8; i++){
mpz_clear(bns[i]);
}
// mpz_clear(dSpectralWeight);
mpz_clear(product);
mpz_clear(magipi);
mpz_clear(magisw);
mpf_clear(magifpi);
mpf_clear(mpsft);
mpf_clear(mpa1);
mpf_clear(mpb1);
mpf_clear(mpt1);
mpf_clear(mpp1);
mpf_clear(mpa2);
mpf_clear(mpb2);
mpf_clear(mpt2);
mpf_clear(mpp2);
memcpy(output, hash, 32);
}
