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); }