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
}
