void ParamsServlet::service(servlet::HttpServletRequest& req, servlet::HttpServletResponse& resp) { std::ostream &out=resp.getOutputStream(); renderHeader(out); testParams(req,resp); renderForm(req,resp); renderFooter(out); }
ConstantParameter(Real value, const Constraint& constraint) : Parameter( 1, boost::shared_ptr<Parameter::Impl>(new ConstantParameter::Impl), constraint) { params_[0] = value; QL_REQUIRE(testParams(params_), value << ": invalid value"); }
bool test(const Array& params) const { Size k=0; for (Size i=0; i<arguments_.size(); i++) { Size size = arguments_[i].size(); Array testParams(size); for (Size j=0; j<size; j++, k++) testParams[j] = params[k]; if (!arguments_[i].testParams(testParams)) return false; } return true; }
// main(). Drives this example by creating an instance of the TestClass and // instances of functors. Then the functors are invoked. int main() { testDirect(); testBase(); testParams(); testReturnDirect(); testReturnBase(); testReturnParams(); testGlobalDirect(); testGlobalBase(); testGlobalParams(); testGlobalReturnDirect(); testGlobalReturnBase(); testGlobalReturnParams(); ArGlobalFunctor2<bool, std::string> f(&function); f.setP2("hello"); f.invoke(true); return(0); }
void PersistenceTest() { // dummy load of SceneIO, otherwise PersistenceService won't be available mitk::PersistenceService::LoadModule(); PERSISTENCE_GET_SERVICE_MACRO CPPUNIT_ASSERT_MESSAGE("Testing availability of the PersistenceService.", persistenceService != NULL); // Initialize testable parameter values std::string defaultPersistenceFile = persistenceService->GetDefaultPersistenceFile(); PersistenceTestClass autoLoadTestClass; autoLoadTestClass.id = testClassId; if (itksys::SystemTools::FileExists(defaultPersistenceFile.c_str(), true) && persistenceService->GetAutoLoadAndSave()) { /// Test auto load/save of the PersistenceService. itksys::SystemTools::RemoveFile(defaultPersistenceFile.c_str()); autoLoadTestClass.FromPropertyList(); testParams(autoLoadTestClass, "autoLoadTestClass"); } std::string testTempFile = mitk::IOUtil::CreateTemporaryFile("XXXXXX.mitk"); std::string testXmlTempFile = mitk::IOUtil::CreateTemporaryFile("PersistenceTestFileXXXXXX.xml"); MITK_INFO << "Testing standard write to scene file/xml file."; PersistenceTestClass testClass; testClass.id = testClassId; testClass.param1 = param1; testClass.param2 = param2; testClass.param3 = param3; CPPUNIT_ASSERT_MESSAGE("Testing to save a scene file", testClass.Save(testTempFile)); CPPUNIT_ASSERT_MESSAGE("testing to save an xml file", testClass.Save(testXmlTempFile)); CPPUNIT_ASSERT_MESSAGE("Testing read from scene file: persistenceService->RemovePropertyList(testClassId)", persistenceService->RemovePropertyList(testClassId)); PersistenceTestClass testClass2; testClass2.id = testClassId; CPPUNIT_ASSERT_MESSAGE("Testing read from scene file: testClass2.Load(testTempFile.path())", testClass2.Load(testTempFile)); testParams(testClass2, "testClass2"); CPPUNIT_ASSERT_MESSAGE("Testing read from xml file: persistenceService->RemovePropertyList(testClassId)", persistenceService->RemovePropertyList(testClassId)); PersistenceTestClass testClass3; testClass3.id = testClassId; CPPUNIT_ASSERT_MESSAGE("Testing read from xml file: testClass3.Load(testXmlTempFile.path())", testClass3.Load(testXmlTempFile)); testParams(testClass3, "testClass3"); CPPUNIT_ASSERT_MESSAGE( "Testing appendChanges functionality with scene load/write: persistenceService->RemovePropertyList(testClassId)", persistenceService->RemovePropertyList(testClassId)); CPPUNIT_ASSERT_MESSAGE( "Testing appendChanges functionality with scene load/write: persistenceService->Save(testTempFile.path())", persistenceService->Save(testTempFile, true)); CPPUNIT_ASSERT_MESSAGE( "Testing appendChanges functionality with scene load/write: persistenceService->Load(testTempFile.path())", persistenceService->Load(testTempFile)); PersistenceTestClass testClass4; testClass4.id = testClassId; testClass4.FromPropertyList(); testParams(testClass4, "testClass4"); CPPUNIT_ASSERT_MESSAGE( "Testing appendChanges functionality with xml load/write: persistenceService->RemovePropertyList(testClassId)", persistenceService->RemovePropertyList(testClassId)); CPPUNIT_ASSERT_MESSAGE( "Testing appendChanges functionality with xml load/write: persistenceService->Save(testXmlTempFile.path())", persistenceService->Save(testXmlTempFile, true)); CPPUNIT_ASSERT_MESSAGE( "Testing appendChanges functionality with xml load/write: persistenceService->Load(testXmlTempFile.path())", persistenceService->Load(testXmlTempFile)); PersistenceTestClass testClass5; testClass5.id = testClassId; testClass5.FromPropertyList(); testParams(testClass5, "testClass5"); // Test Observer Functionality TestPropertyListReplacedObserver testObserver; testObserver.m_Id = testClassId; persistenceService->AddPropertyListReplacedObserver(&testObserver); persistenceService->Load(testTempFile); CPPUNIT_ASSERT_MESSAGE( "Testing observer functionality: testObserver.counter == 2, testObserver.counter is " + testObserver.counter, testObserver.counter == 2); autoLoadTestClass.param1 = param1; autoLoadTestClass.param2 = param2; autoLoadTestClass.param3 = param3; autoLoadTestClass.ToPropertyList(); }
bool BitcoinMiner2_mineProbableChain(primecoinBlock_t* block, mpz_class& mpzFixedMultiplier, bool& fNewBlock, unsigned int& nTriedMultiplier, unsigned int& nProbableChainLength, unsigned int& nTests, unsigned int& nPrimesHit, sint32 threadIndex, mpz_class& mpzHash, unsigned int nPrimorialMultiplier) { mpz_class mpzChainOrigin; mpz_class mpzFinalFixedMultiplier = mpzFixedMultiplier * mpzHash; mpz_class mpzTemp; uint32 nTime = GetTickCount(); cSieve_prepare(mpzFinalFixedMultiplier, block->nBits>>24); nTime = GetTickCount()-nTime; //printf("cSieve prep time: %d\n", nTime); unsigned int nPrimorialSeq = 0; while (vPrimes[nPrimorialSeq + 1] <= nPrimorialMultiplier) nPrimorialSeq++; // Allocate GMP variables for primality tests CPrimalityTestParams testParams(block->nBits, nPrimorialSeq); { unsigned long lDivisor = 1; unsigned int i; testParams.vFastDivSeq.push_back(nPrimorialSeq); for (i = 1; i <= nFastDivPrimes; i++) { // Multiply primes together until the result won't fit an unsigned long if (lDivisor < ULONG_MAX / vPrimes[nPrimorialSeq + i]) lDivisor *= vPrimes[nPrimorialSeq + i]; else { testParams.vFastDivisors.push_back(lDivisor); testParams.vFastDivSeq.push_back(nPrimorialSeq + i); lDivisor = 1; } } // Finish off by multiplying as many primes as possible while (lDivisor < ULONG_MAX / vPrimes[nPrimorialSeq + i]) { lDivisor *= vPrimes[nPrimorialSeq + i]; i++; } testParams.vFastDivisors.push_back(lDivisor); testParams.vFastDivSeq.push_back(nPrimorialSeq + i); testParams.nFastDivisorsSize = testParams.vFastDivisors.size(); } // References to counters; unsigned int& nChainLengthCunningham1 = testParams.nChainLengthCunningham1; unsigned int& nChainLengthCunningham2 = testParams.nChainLengthCunningham2; unsigned int& nChainLengthBiTwin = testParams.nChainLengthBiTwin; uint32 debugStats_primes = 0; uint32 debugStats_multipliersTested = 0; while( block->serverData.blockHeight == jhMiner_getCurrentWorkBlockHeight(block->threadIndex) ) { uint32 sieveFlags; uint32 multiplier = cSieve_findNextMultiplier(&sieveFlags); if( multiplier == 0 ) { // mix in next layer //printf("Layer finished [%d]\n", cSieve->currentSieveLayerIdx); if( cSieve_sieveNextLayer() == false ) break; mpzFinalFixedMultiplier = cSieve->mpzFixedMultiplier; //printf("[%02d] debugStats_multipliersTested: %d\n", cSieve->currentSieveLayerIdx, debugStats_multipliersTested); //printf("[%02d] debugStats_primes: %d\n", cSieve->currentSieveLayerIdx, debugStats_primes); //double primality = (double)debugStats_primes / (double)debugStats_multipliersTested; //printf("[%02d] debugStats_primality: %lf\n", cSieve->currentSieveLayerIdx, primality); debugStats_primes = 0; debugStats_multipliersTested = 0; continue; } //// test for sieve bugs C1 //if( (sieveFlags&SIEVE_FLAG_C1_COMPOSITE)==0 && (rand()%10)==0 ) //{ // // test c1 // for(uint32 lt=0; lt<cSieve->chainLength; lt++) // { // uint32 aMult = 1<<lt; // mpzChainOrigin = mpzFinalFixedMultiplier * multiplier * aMult - 1; // for(uint32 f=0; f<cSieve->numPrimeFactors; f++) // { // uint32 mod = mpz_mod_ui(mpzTemp.get_mpz_t(), mpzChainOrigin.get_mpz_t(), vPrimes[f]); // if( mod == 0 ) // printf("c1 div by %d possible\n", vPrimes[f]);//__debugbreak(); // } // } //} //// test for sieve bugs C2 //if( (sieveFlags&SIEVE_FLAG_C2_COMPOSITE)==0 && (rand()%10)==0 ) //{ // // test c1 // for(uint32 lt=0; lt<cSieve->chainLength; lt++) // { // uint32 aMult = 1<<lt; // mpzChainOrigin = mpzFinalFixedMultiplier * multiplier * aMult + 1; // for(uint32 f=0; f<cSieve->numPrimeFactors; f++) // { // uint32 mod = mpz_mod_ui(mpzTemp.get_mpz_t(), mpzChainOrigin.get_mpz_t(), vPrimes[f]); // if( mod == 0 ) // printf("c2 div by %d possible\n", vPrimes[f]);//__debugbreak(); // } // } //} // test for sieve bugs BT //if( (sieveFlags&SIEVE_FLAG_BT_COMPOSITE)==0 ) //{ // // test c1 // mpzChainOrigin = mpzFinalFixedMultiplier * multiplier + 1; // for(uint32 f=0; f<cSieve->numPrimeFactors; f++) // { // uint32 mod = mpz_mod_ui(mpzTemp.get_mpz_t(), mpzChainOrigin.get_mpz_t(), vPrimes[f]); // if( mod == 0 ) // printf("bt-c2 div by %d possible\n", vPrimes[f]); // } // // test c2 // mpzChainOrigin = mpzFinalFixedMultiplier * multiplier - 1; // for(uint32 f=0; f<cSieve->numPrimeFactors; f++) // { // uint32 mod = mpz_mod_ui(mpzTemp.get_mpz_t(), mpzChainOrigin.get_mpz_t(), vPrimes[f]); // if( mod == 0 ) // printf("bt-c2 div by %d possible\n", vPrimes[f]); // } //} //mpzChainOrigin = mpzFinalFixedMultiplier * multiplier; mpz_mul_ui(mpzChainOrigin.get_mpz_t(), mpzFinalFixedMultiplier.get_mpz_t(), multiplier); nChainLengthCunningham1 = 0; nChainLengthCunningham2 = 0; nChainLengthBiTwin = 0; bool canSubmitAsShare = ProbablePrimeChainTestFast2(mpzChainOrigin, testParams, sieveFlags, multiplier); nProbableChainLength = max(max(nChainLengthCunningham1, nChainLengthCunningham2), nChainLengthBiTwin); if( nProbableChainLength >= 0x01000000 ) debugStats_primes++; debugStats_multipliersTested++; //bool canSubmitAsShare = ProbablePrimeChainTestFast(mpzChainOrigin, testParams); //CBigNum bnChainOrigin; //bnChainOrigin.SetHex(mpzChainOrigin.get_str(16)); //bool canSubmitAsShare = ProbablePrimeChainTestBN(bnChainOrigin, block->serverData.nBitsForShare, false, nChainLengthCunningham1, nChainLengthCunningham2, nChainLengthBiTwin); if( nProbableChainLength >= 0x04000000 ) { sint32 chainDif = (nProbableChainLength>>24) - 7; primeStats.nChainHit += pow(8, (float)chainDif); //primeStats.nChainHit += pow(8, ((float)((double)nProbableChainLength / (double)0x1000000))-7.0); //primeStats.nChainHit += pow(8, floor((float)((double)nProbableChainLength / (double)0x1000000)) - 7); nTests = 0; primeStats.fourChainCount ++; if (nProbableChainLength >= 0x5000000) { primeStats.fiveChainCount ++; if (nProbableChainLength >= 0x6000000) { primeStats.sixChainCount ++; if (nProbableChainLength >= 0x7000000) primeStats.sevenChainCount ++; } } } //if( nBitsGen >= 0x03000000 ) // printf("%08X\n", nBitsGen); primeStats.primeChainsFound++; //if( nProbableChainLength > 0x03000000 ) // primeStats.qualityPrimesFound++; if( nProbableChainLength > primeStats.bestPrimeChainDifficulty ) primeStats.bestPrimeChainDifficulty = nProbableChainLength; if(nProbableChainLength >= block->serverData.nBitsForShare) { // note: mpzPrimeChainMultiplier does not include the blockHash multiplier mpz_div(block->mpzPrimeChainMultiplier.get_mpz_t(), mpzChainOrigin.get_mpz_t(), mpzHash.get_mpz_t()); //mpz_lsh(block->mpzPrimeChainMultiplier.get_mpz_t(), mpzFixedMultiplier.get_mpz_t(), multiplier); // update server data block->serverData.client_shareBits = nProbableChainLength; // generate block raw data uint8 blockRawData[256] = {0}; memcpy(blockRawData, block, 80); uint32 writeIndex = 80; sint32 lengthBN = 0; CBigNum bnPrimeChainMultiplier; bnPrimeChainMultiplier.SetHex(block->mpzPrimeChainMultiplier.get_str(16)); std::vector<unsigned char> bnSerializeData = bnPrimeChainMultiplier.getvch(); lengthBN = bnSerializeData.size(); *(uint8*)(blockRawData+writeIndex) = (uint8)lengthBN; // varInt (we assume it always has a size low enough for 1 byte) writeIndex += 1; memcpy(blockRawData+writeIndex, &bnSerializeData[0], lengthBN); writeIndex += lengthBN; // switch endianness for(uint32 f=0; f<256/4; f++) { *(uint32*)(blockRawData+f*4) = _swapEndianessU32(*(uint32*)(blockRawData+f*4)); } time_t now = time(0); struct tm * timeinfo; timeinfo = localtime (&now); char sNow [80]; strftime (sNow, 80, "%x - %X",timeinfo); printf("%s - SHARE FOUND !!! (Th#: %u Multiplier: %d Layer: %d) --- DIFF: %f %s %s\n", sNow, threadIndex, multiplier, cSieve->currentSieveLayerIdx, (float)((double)nProbableChainLength / (double)0x1000000), nProbableChainLength >= 0x6000000 ? ">6":"", nProbableChainLength >= 0x7000000 ? ">7":""); // submit this share if (jhMiner_pushShare_primecoin(blockRawData, block)) primeStats.foundShareCount ++; //printf("Probable prime chain found for block=%s!!\n Target: %s\n Length: (%s %s %s)\n", block.GetHash().GetHex().c_str(),TargetToString(block.nBits).c_str(), TargetToString(nChainLengthCunningham1).c_str(), TargetToString(nChainLengthCunningham2).c_str(), TargetToString(nChainLengthBiTwin).c_str()); //nProbableChainLength = max(max(nChainLengthCunningham1, nChainLengthCunningham2), nChainLengthBiTwin); // since we are using C structs here we have to make sure the memory for the CBigNum in the block is freed again //delete *psieve; //*psieve = NULL; //block->bnPrimeChainMultiplier = NULL; RtlZeroMemory(blockRawData, 256); //delete *psieve; //*psieve = NULL; // dont quit if we find a share, there could be other shares in the remaining prime candidates nTests = 0; // tehere is a good chance to find more shares so search a litle more. //block->nonce++; //return true; //break; //if (multipleShare) } }
int mitkPersistenceTest(int /*argc*/, char* /*argv*/[]) { MITK_TEST_BEGIN("PersistenceTest") // dummy load of SceneIO, otherwise PersistenceService won't be available //mitk::PersistenceService::LoadModule(); MITK_INFO << "Testing availability of the PersistenceService."; PERSISTENCE_GET_SERVICE_MACRO MITK_TEST_CONDITION_REQUIRED(persistenceService, "IPersistenceService available") MITK_INFO << "Initialize testable parameter values."; Poco::File defaultPersistenceFile(persistenceService->GetDefaultPersistenceFile()); PersistenceTestClass autoLoadTestClass; autoLoadTestClass.id = testClassId; if( defaultPersistenceFile.exists() && persistenceService->GetAutoLoadAndSave() ) { MITK_INFO << "Testing auto load/save of the PersistenceService."; defaultPersistenceFile.remove(); autoLoadTestClass.FromPropertyList(); testParams( autoLoadTestClass, "autoLoadTestClass" ); } MITK_INFO << "Removing left-over test files."; Poco::File testTempFile("PersistenceTestFile.mitk"); if( testTempFile.exists() ) testTempFile.remove(false); Poco::File testXmlTempFile("PersistenceTestFile.xml"); if( testXmlTempFile.exists() ) testXmlTempFile.remove(false); MITK_INFO << "Testing standard write to scene file/xml file."; PersistenceTestClass testClass; testClass.id = testClassId; testClass.param1 = param1; testClass.param2 = param2; testClass.param3 = param3; MITK_TEST_CONDITION_REQUIRED( testClass.Save(testTempFile.path()), "testClass.Save(testTempFile.path())"); MITK_TEST_CONDITION_REQUIRED( testClass.Save(testXmlTempFile.path()), "testClass.Save(testTempFile.path())"); MITK_INFO << "Testing read from scene file."; MITK_TEST_CONDITION_REQUIRED( persistenceService->RemovePropertyList(testClassId), "persistenceService->RemovePropertyList(testClassId)"); PersistenceTestClass testClass2; testClass2.id = testClassId; MITK_TEST_CONDITION_REQUIRED( testClass2.Load(testTempFile.path()), "testClass2.Load(testTempFile.path())"); testParams( testClass2, "testClass2" ); MITK_INFO << "Testing read from xml file."; MITK_TEST_CONDITION_REQUIRED( persistenceService->RemovePropertyList(testClassId), "persistenceService->RemovePropertyList(testClassId)"); PersistenceTestClass testClass3; testClass3.id = testClassId; MITK_TEST_CONDITION_REQUIRED( testClass3.Load(testXmlTempFile.path()), "testClass3.Load(testXmlTempFile.path())"); testParams( testClass3, "testClass3" ); MITK_INFO << "Testing appendChanges functionality with scene load/write."; MITK_TEST_CONDITION_REQUIRED( persistenceService->RemovePropertyList(testClassId), "persistenceService->RemovePropertyList(testClassId)"); MITK_TEST_CONDITION_REQUIRED( persistenceService->Save(testTempFile.path(), true), "persistenceService->Save(testTempFile.path())"); MITK_TEST_CONDITION_REQUIRED( persistenceService->Load(testTempFile.path()), "persistenceService->Load(testTempFile.path())"); PersistenceTestClass testClass4; testClass4.id = testClassId; testClass4.FromPropertyList(); testParams( testClass4, "testClass4" ); MITK_INFO << "Testing appendChanges functionality with xml load/write."; MITK_TEST_CONDITION_REQUIRED( persistenceService->RemovePropertyList(testClassId), "persistenceService->RemovePropertyList(testClassId)"); MITK_TEST_CONDITION_REQUIRED( persistenceService->Save(testXmlTempFile.path(), true), "persistenceService->Save(testXmlTempFile.path())"); MITK_TEST_CONDITION_REQUIRED( persistenceService->Load(testXmlTempFile.path()), "persistenceService->Load(testXmlTempFile.path())"); PersistenceTestClass testClass5; testClass5.id = testClassId; testClass5.FromPropertyList(); testParams( testClass5, "testClass5" ); MITK_INFO << "Testing observer functionality."; TestPropertyListReplacedObserver testObserver; testObserver.m_Id = testClassId; persistenceService->AddPropertyListReplacedObserver( &testObserver ); persistenceService->Load(testTempFile.path()); MITK_TEST_CONDITION( testObserver.counter == 2, "testObserver.counter == 2, testObserver.counter is " << testObserver.counter ); MITK_INFO << "Cleaning test files."; if( testXmlTempFile.exists() ) testXmlTempFile.remove(false); if( testTempFile.exists() ) testTempFile.remove(false); autoLoadTestClass.param1 = param1; autoLoadTestClass.param2 = param2; autoLoadTestClass.param3 = param3; autoLoadTestClass.ToPropertyList(); MITK_TEST_END() }
// Mine probable prime chain of form: n = h * p# +/- 1 bool MineProbablePrimeChain(Reap_CPU_param* state, Work& tempwork, CSieveOfEratosthenes& psieve, mpz_class& mpzFixedMultiplier, bool& fNewBlock, unsigned int& nTriedMultiplier, unsigned int& nProbableChainLength, unsigned int& nTests, unsigned int& nPrimesHit, unsigned int& nChainsHit, mpz_class& mpzHash, unsigned int nPrimorialMultiplier) { nProbableChainLength = 0; nPrimesHit = 0; nChainsHit = 0; //const unsigned int nBits = block.nBits; const unsigned int nBits = *(uint*)&tempwork.data[72]; bool use_gpu_fermat_test = globalconfs.coin.config.GetValue<bool>("use_gpu_fermat_test"); if (fNewBlock && psieve.inited) { // Must rebuild the sieve psieve.Deinit(); } fNewBlock = false; int64 nStart; // microsecond timer if (!psieve.inited) { // Build sieve nStart = ticker()*1000; psieve.InitAndWeave(state, nSieveSize, nBits, mpzHash, mpzFixedMultiplier); if (globalconfs.coin.config.GetValue<bool>("debug")) printf("MineProbablePrimeChain() : new sieve (%lu/%u) ready in %uus\n", psieve.CandidateList.size(), nSieveSize, (unsigned int) (ticker()*1000 - nStart)); } mpz_class mpzHashMultiplier = mpzHash * mpzFixedMultiplier; mpz_class mpzChainOrigin; // Determine the sequence number of the round primorial unsigned int nPrimorialSeq = 0; while (vPrimes[nPrimorialSeq + 1] <= nPrimorialMultiplier) nPrimorialSeq++; // Allocate GMP variables for primality tests CPrimalityTestParams testParams(nBits, nPrimorialSeq); nStart = ticker()*1000; // References to counters; unsigned int& nChainLengthCunningham1 = testParams.nChainLengthCunningham1; unsigned int& nChainLengthCunningham2 = testParams.nChainLengthCunningham2; unsigned int& nChainLengthBiTwin = testParams.nChainLengthBiTwin; //cout << "PSIEVIOSIE" << psieve.CandidateList.size() << endl; for(uint i=0; i<psieve.CandidateList.size(); ++i) { nTriedMultiplier = psieve.CandidateList[i]&0x3FFFFFFFU; uint sievenumber = psieve.CandidateList[i]>>30; if (sievenumber == 0) sievenumber=3; if (nTriedMultiplier == 0) //will crash otherwise continue; ++nTests; if (tempwork.time != current_work.time) { //cout << "Tempwork.time != curnetopqi" << tempwork.time << " " << current_work.time << endl; break; } mpzChainOrigin = mpzHashMultiplier * (nTriedMultiplier&0x3FFFFFFFU); nChainLengthCunningham1 = 0; nChainLengthCunningham2 = 0; nChainLengthBiTwin = 0; if (ProbablePrimeChainTestFast(mpzChainOrigin, testParams, sievenumber, use_gpu_fermat_test)) { mpz_t mpzPrimeChainMultiplier; mpz_init(mpzPrimeChainMultiplier); mpz_mul_ui(mpzPrimeChainMultiplier,mpzFixedMultiplier.get_mpz_t(),nTriedMultiplier); { //gmp_printf("Found chain! Mult: %Zx\n",mpzPrimeChainMultiplier); vector<uchar> auxdata = XPM_create_auxdata(&mpzPrimeChainMultiplier); CPU_Got_share(state,tempwork,auxdata); } mpz_clear(mpzPrimeChainMultiplier); nProbableChainLength = std::max(std::max(nChainLengthCunningham1, nChainLengthCunningham2), nChainLengthBiTwin); return true; } nProbableChainLength = std::max(std::max(nChainLengthCunningham1, nChainLengthCunningham2), nChainLengthBiTwin); if(TargetGetLength(nProbableChainLength) >= 1) nPrimesHit++; if(TargetGetLength(nProbableChainLength) >= nStatsChainLength) nChainsHit++; } // power tests completed for the sieve //if (fDebug && GetBoolArg("-printmining")) //printf("MineProbablePrimeChain() : %u tests (%u primes and %u %d-chains) in %uus\n", nTests, nPrimesHit, nChainsHit, nStatsChainLength, (unsigned int) (GetTimeMicros() - nStart)); psieve.Deinit(); fNewBlock = true; // notify caller to change nonce return false; // stop as new block arrived }