#include "txdb.h"
#include "miner.h"
#include "kernel.h"
+#include "kernel_worker.h"
using namespace std;
int static FormatHashBlocks(void* pbuffer, unsigned int len)
{
- unsigned char* pdata = (unsigned char*)pbuffer;
- unsigned int blocks = 1 + ((len + 8) / 64);
- unsigned char* pend = pdata + 64 * blocks;
+ auto pdata = (unsigned char*)pbuffer;
+ auto blocks = 1 + ((len + 8) / 64);
+ auto pend = pdata + 64 * blocks;
memset(pdata + len, 0, 64 * blocks - len);
pdata[len] = 0x80;
- unsigned int bits = len * 8;
+ auto bits = len * 8;
pend[-1] = (bits >> 0) & 0xff;
pend[-2] = (bits >> 8) & 0xff;
pend[-3] = (bits >> 16) & 0xff;
ptx = ptxIn;
dPriority = dFeePerKb = 0;
}
-
- void print() const
- {
- printf("COrphan(hash=%s, dPriority=%.1f, dFeePerKb=%.1f)\n",
- ptx->GetHash().ToString().substr(0,10).c_str(), dPriority, dFeePerKb);
- BOOST_FOREACH(uint256 hash, setDependsOn)
- printf(" setDependsOn %s\n", hash.ToString().substr(0,10).c_str());
- }
};
uint32_t nLastCoinStakeSearchInterval = 0;
// We want to sort transactions by priority and fee, so:
-typedef boost::tuple<double, double, CTransaction*> TxPriority;
+typedef tuple<double, double, CTransaction*> TxPriority;
class TxPriorityCompare
{
bool byFee;
{
if (byFee)
{
- if (a.get<1>() == b.get<1>())
- return a.get<0>() < b.get<0>();
- return a.get<1>() < b.get<1>();
+ if (get<1>(a) == get<1>(b))
+ return get<0>(a) < get<0>(b);
+ return get<1>(a) < get<1>(b);
}
else
{
- if (a.get<0>() == b.get<0>())
- return a.get<1>() < b.get<1>();
- return a.get<0>() < b.get<0>();
+ if (get<0>(a) == get<0>(b))
+ return get<1>(a) < get<1>(b);
+ return get<0>(a) < get<0>(b);
}
}
};
bool fProofOfStake = txCoinStake != NULL;
// Create new block
- auto_ptr<CBlock> pblock(new CBlock());
+ unique_ptr<CBlock> pblock(new CBlock());
if (!pblock.get())
return NULL;
}
// Largest block you're willing to create:
- unsigned int nBlockMaxSize = GetArg("-blockmaxsize", MAX_BLOCK_SIZE_GEN/2);
+ auto nBlockMaxSize = GetArgUInt("-blockmaxsize", MAX_BLOCK_SIZE_GEN/2);
// Limit to betweeen 1K and MAX_BLOCK_SIZE-1K for sanity:
- nBlockMaxSize = std::max((unsigned int)1000, std::min((unsigned int)(MAX_BLOCK_SIZE-1000), nBlockMaxSize));
+ nBlockMaxSize = max(1000u, min(MAX_BLOCK_SIZE-1000u, nBlockMaxSize));
// How much of the block should be dedicated to high-priority transactions,
// included regardless of the fees they pay
- unsigned int nBlockPrioritySize = GetArg("-blockprioritysize", 27000);
- nBlockPrioritySize = std::min(nBlockMaxSize, nBlockPrioritySize);
+ auto nBlockPrioritySize = GetArgUInt("-blockprioritysize", 27000);
+ nBlockPrioritySize = min(nBlockMaxSize, nBlockPrioritySize);
// Minimum block size you want to create; block will be filled with free transactions
// until there are no more or the block reaches this size:
- unsigned int nBlockMinSize = GetArg("-blockminsize", 0);
- nBlockMinSize = std::min(nBlockMaxSize, nBlockMinSize);
+ auto nBlockMinSize = GetArgUInt("-blockminsize", 0);
+ nBlockMinSize = min(nBlockMaxSize, nBlockMinSize);
// Fee-per-kilobyte amount considered the same as "free"
// Be careful setting this: if you set it to zero then
// a transaction spammer can cheaply fill blocks using
// 1-satoshi-fee transactions. It should be set above the real
// cost to you of processing a transaction.
- int64_t nMinTxFee = MIN_TX_FEE;
- if (mapArgs.count("-mintxfee"))
- ParseMoney(mapArgs["-mintxfee"], nMinTxFee);
+ auto nMinTxFee = MIN_TX_FEE;
+ if (mapArgs.count("-mintxfee")) {
+ bool fResult = ParseMoney(mapArgs["-mintxfee"], nMinTxFee);
+ if (!fResult) // Parse error
+ nMinTxFee = MIN_TX_FEE;
+ }
- CBlockIndex* pindexPrev = pindexBest;
+ auto pindexPrev = pindexBest;
pblock->nBits = GetNextTargetRequired(pindexPrev, fProofOfStake);
// This vector will be sorted into a priority queue:
vector<TxPriority> vecPriority;
vecPriority.reserve(mempool.mapTx.size());
- for (map<uint256, CTransaction>::iterator mi = mempool.mapTx.begin(); mi != mempool.mapTx.end(); ++mi)
+ for (auto mi = mempool.mapTx.begin(); mi != mempool.mapTx.end(); ++mi)
{
- CTransaction& tx = (*mi).second;
+ auto& tx = (*mi).second;
if (tx.IsCoinBase() || tx.IsCoinStake() || !tx.IsFinal())
continue;
double dPriority = 0;
int64_t nTotalIn = 0;
bool fMissingInputs = false;
- BOOST_FOREACH(const CTxIn& txin, tx.vin)
+ for(const auto& txin : tx.vin)
{
// Read prev transaction
CTransaction txPrev;
nTotalIn += mempool.mapTx[txin.prevout.hash].vout[txin.prevout.n].nValue;
continue;
}
- int64_t nValueIn = txPrev.vout[txin.prevout.n].nValue;
+ auto nValueIn = txPrev.vout[txin.prevout.n].nValue;
nTotalIn += nValueIn;
int nConf = txindex.GetDepthInMainChain();
if (fMissingInputs) continue;
// Priority is sum(valuein * age) / txsize
- unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
+ auto nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
dPriority /= nTxSize;
// This is a more accurate fee-per-kilobyte than is used by the client code, because the
// client code rounds up the size to the nearest 1K. That's good, because it gives an
// incentive to create smaller transactions.
- double dFeePerKb = double(nTotalIn-tx.GetValueOut()) / (double(nTxSize)/1000.0);
+ auto dFeePerKb = double(nTotalIn-tx.GetValueOut()) / (double(nTxSize)/1000.0);
if (porphan)
{
bool fSortedByFee = (nBlockPrioritySize <= 0);
TxPriorityCompare comparer(fSortedByFee);
- std::make_heap(vecPriority.begin(), vecPriority.end(), comparer);
+ make_heap(vecPriority.begin(), vecPriority.end(), comparer);
while (!vecPriority.empty())
{
// Take highest priority transaction off the priority queue:
- double dPriority = vecPriority.front().get<0>();
- double dFeePerKb = vecPriority.front().get<1>();
- CTransaction& tx = *(vecPriority.front().get<2>());
+ auto dPriority = get<0>(vecPriority.front());
+ auto dFeePerKb = get<1>(vecPriority.front());
+ auto& tx = *(get<2>(vecPriority.front()));
- std::pop_heap(vecPriority.begin(), vecPriority.end(), comparer);
+ pop_heap(vecPriority.begin(), vecPriority.end(), comparer);
vecPriority.pop_back();
// Size limits
- unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
+ auto nTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
if (nBlockSize + nTxSize >= nBlockMaxSize)
continue;
// Legacy limits on sigOps:
- unsigned int nTxSigOps = tx.GetLegacySigOpCount();
+ auto nTxSigOps = tx.GetLegacySigOpCount();
if (nBlockSigOps + nTxSigOps >= MAX_BLOCK_SIGOPS)
continue;
if (tx.nTime > GetAdjustedTime() || (fProofOfStake && tx.nTime > txCoinStake->nTime))
continue;
- // Simplify transaction fee - allow free = false
- int64_t nMinFee = tx.GetMinFee(nBlockSize, true, GMF_BLOCK, nTxSize);
-
// Skip free transactions if we're past the minimum block size:
if (fSortedByFee && (dFeePerKb < nMinTxFee) && (nBlockSize + nTxSize >= nBlockMinSize))
continue;
{
fSortedByFee = true;
comparer = TxPriorityCompare(fSortedByFee);
- std::make_heap(vecPriority.begin(), vecPriority.end(), comparer);
+ make_heap(vecPriority.begin(), vecPriority.end(), comparer);
}
// Connecting shouldn't fail due to dependency on other memory pool transactions
if (!tx.FetchInputs(txdb, mapTestPoolTmp, false, true, mapInputs, fInvalid))
continue;
- int64_t nTxFees = tx.GetValueIn(mapInputs)-tx.GetValueOut();
+ // Transaction fee
+ auto nTxFees = tx.GetValueIn(mapInputs)-tx.GetValueOut();
+ auto nMinFee = tx.GetMinFee(nBlockSize, true, GMF_BLOCK, nTxSize);
if (nTxFees < nMinFee)
continue;
+ // Sigops accumulation
nTxSigOps += tx.GetP2SHSigOpCount(mapInputs);
if (nBlockSigOps + nTxSigOps >= MAX_BLOCK_SIGOPS)
continue;
}
// Add transactions that depend on this one to the priority queue
- uint256 hash = tx.GetHash();
+ auto hash = tx.GetHash();
if (mapDependers.count(hash))
{
- BOOST_FOREACH(COrphan* porphan, mapDependers[hash])
+ for(auto porphan : mapDependers[hash])
{
if (!porphan->setDependsOn.empty())
{
if (porphan->setDependsOn.empty())
{
vecPriority.push_back(TxPriority(porphan->dPriority, porphan->dFeePerKb, porphan->ptx));
- std::push_heap(vecPriority.begin(), vecPriority.end(), comparer);
+ push_heap(vecPriority.begin(), vecPriority.end(), comparer);
}
}
}
bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey)
{
- uint256 hashBlock = pblock->GetHash();
- uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
+ auto hashBlock = pblock->GetHash();
+ auto hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
if(!pblock->IsProofOfWork())
return error("CheckWork() : %s is not a proof-of-work block", hashBlock.GetHex().c_str());
bool CheckStake(CBlock* pblock, CWallet& wallet)
{
uint256 proofHash = 0, hashTarget = 0;
- uint256 hashBlock = pblock->GetHash();
+ auto hashBlock = pblock->GetHash();
if(!pblock->IsProofOfStake())
return error("CheckStake() : %s is not a proof-of-stake block", hashBlock.GetHex().c_str());
}
// Precalculated SHA256 contexts and metadata
-// (txid, vout.n) => (SHA256_CTX, (tx.nTime, nAmount))
-typedef std::map<std::pair<uint256, unsigned int>, std::pair<SHA256_CTX, std::pair<uint32_t, uint64_t> > > MidstateMap;
+// (txid, vout.n) => (kernel, (tx.nTime, nAmount))
+typedef map<pair<uint256, unsigned int>, pair<vector<unsigned char>, pair<uint32_t, uint64_t> > > MidstateMap;
-// Fill the inputs map with precalculated states and metadata
+// Fill the inputs map with precalculated contexts and metadata
bool FillMap(CWallet *pwallet, uint32_t nUpperTime, MidstateMap &inputsMap)
{
// Choose coins to use
- int64_t nBalance = pwallet->GetBalance();
+ auto nBalance = pwallet->GetBalance();
if (nBalance <= nReserveBalance)
return false;
CBlock block;
CTxIndex txindex;
- for(CoinsSet::const_iterator pcoin = setCoins.begin(); pcoin != setCoins.end(); pcoin++)
+ for(auto pcoin = setCoins.begin(); pcoin != setCoins.end(); pcoin++)
{
- pair<uint256, uint32_t> key = make_pair(pcoin->first->GetHash(), pcoin->second);
+ auto key = make_pair(pcoin->first->GetHash(), pcoin->second);
// Skip existent inputs
if (inputsMap.find(key) != inputsMap.end())
if (nStakeMinAge + block.nTime > nTime - nMaxStakeSearchInterval)
continue;
+ // Get stake modifier
uint64_t nStakeModifier = 0;
if (!GetKernelStakeModifier(block.GetHash(), nStakeModifier))
continue;
- SHA256_CTX ctx;
- // Calculate midstate using (modifier, block time, tx offset, tx time, output number)
- GetKernelMidstate(nStakeModifier, block.nTime, txindex.pos.nTxPos - txindex.pos.nBlockPos, pcoin->first->nTime, pcoin->second, ctx);
+ // Build static part of kernel
+ CDataStream ssKernel(SER_GETHASH, 0);
+ ssKernel << nStakeModifier;
+ ssKernel << block.nTime << (txindex.pos.nTxPos - txindex.pos.nBlockPos) << pcoin->first->nTime << pcoin->second;
- // (txid, vout.n) => (SHA256_CTX, (tx.nTime, nAmount))
- inputsMap[key] = make_pair(ctx, make_pair(pcoin->first->nTime, pcoin->first->vout[pcoin->second].nValue));
+ // (txid, vout.n) => (kernel, (tx.nTime, nAmount))
+ inputsMap[key] = { vector<unsigned char>(ssKernel.begin(), ssKernel.end()), { pcoin->first->nTime, pcoin->first->vout[pcoin->second].nValue } };
}
nStakeInputsMapSize = inputsMap.size();
if (fDebug)
- printf("Stake miner: map of %" PRIu64 " precalculated contexts has been created\n", nStakeInputsMapSize);
+ printf("FillMap() : Map of %" PRIu64 " precalculated contexts has been created by stake miner\n", nStakeInputsMapSize);
}
return true;
}
// Scan inputs map in order to find a solution
-bool ScanMap(const MidstateMap &inputsMap, uint32_t nBits, MidstateMap::key_type &LuckyInput, std::pair<uint256, uint32_t> &solution)
+bool ScanMap(const MidstateMap &inputsMap, uint32_t nBits, MidstateMap::key_type &LuckyInput, pair<uint256, uint32_t> &solution)
{
static uint32_t nLastCoinStakeSearchTime = GetAdjustedTime(); // startup timestamp
uint32_t nSearchTime = GetAdjustedTime();
if (inputsMap.size() > 0 && nSearchTime > nLastCoinStakeSearchTime)
{
// Scanning interval (begintime, endtime)
- std::pair<uint32_t, uint32_t> interval;
-
- interval.first = nSearchTime;
- interval.second = nSearchTime - min(nSearchTime-nLastCoinStakeSearchTime, nMaxStakeSearchInterval);
+ pair<uint32_t, uint32_t> interval = { nSearchTime, nSearchTime - min(nSearchTime-nLastCoinStakeSearchTime, nMaxStakeSearchInterval) };
- // (txid, nout) => (SHA256_CTX, (tx.nTime, nAmount))
- for(MidstateMap::const_iterator input = inputsMap.begin(); input != inputsMap.end(); input++)
+ // (txid, nout) => (kernel, (tx.nTime, nAmount))
+ for(auto input = inputsMap.begin(); input != inputsMap.end(); input++)
{
- SHA256_CTX ctx = input->second.first;
+ auto kernel = (unsigned char *) &input->second.first[0];
// scan(State, Bits, Time, Amount, ...)
- if (ScanMidstateBackward(ctx, nBits, input->second.second.first, input->second.second.second, interval, solution))
+ if (ScanKernelBackward(kernel, nBits, input->second.second.first, input->second.second.second, interval, solution))
{
// Solution found
LuckyInput = input->first; // (txid, nout)
return false;
}
-void StakeMiner(CWallet *pwallet)
+// Stake miner thread
+void ThreadStakeMiner(void* parg)
{
SetThreadPriority(THREAD_PRIORITY_LOWEST);
// Make this thread recognisable as the mining thread
RenameThread("novacoin-miner");
+ auto pwallet = (CWallet*)parg;
MidstateMap inputsMap;
if (!FillMap(pwallet, GetAdjustedTime(), inputsMap))
bool fTrySync = true;
- CBlockIndex* pindexPrev = pindexBest;
- uint32_t nBits = GetNextTargetRequired(pindexPrev, true);
+ auto pindexPrev = pindexBest;
+ auto nBits = GetNextTargetRequired(pindexPrev, true);
+
+ printf("ThreadStakeMinter started\n");
- while (true)
+ try
{
- if (fShutdown)
- return;
+ vnThreadsRunning[THREAD_MINTER]++;
- while (pwallet->IsLocked())
- {
- Sleep(1000);
- if (fShutdown)
- return;
- }
+ MidstateMap::key_type LuckyInput;
+ pair<uint256, uint32_t> solution;
- while (vNodes.empty() || IsInitialBlockDownload())
+ // Main miner loop
+ do
{
- fTrySync = true;
-
- Sleep(1000);
if (fShutdown)
- return;
- }
+ goto _endloop;
- if (fTrySync)
- {
- fTrySync = false;
- if (vNodes.size() < 3 || nBestHeight < GetNumBlocksOfPeers())
+ while (pwallet->IsLocked())
{
Sleep(1000);
- continue;
+ if (fShutdown)
+ goto _endloop; // Don't be afraid to use a goto if that's the best option.
}
- }
-
- MidstateMap::key_type LuckyInput;
- std::pair<uint256, uint32_t> solution;
- if (ScanMap(inputsMap, nBits, LuckyInput, solution))
- {
- SetThreadPriority(THREAD_PRIORITY_NORMAL);
-
- // Remove lucky input from the map
- inputsMap.erase(inputsMap.find(LuckyInput));
+ while (vNodes.empty() || IsInitialBlockDownload())
+ {
+ fTrySync = true;
- CKey key;
- CTransaction txCoinStake;
+ Sleep(1000);
+ if (fShutdown)
+ goto _endloop;
+ }
- // Create new coinstake transaction
- if (!pwallet->CreateCoinStake(LuckyInput.first, LuckyInput.second, solution.second, nBits, txCoinStake, key))
+ if (fTrySync)
{
- string strMessage = _("Warning: Unable to create coinstake transaction, see debug.log for the details. Mining thread has been stopped.");
- strMiscWarning = strMessage;
- printf("*** %s\n", strMessage.c_str());
-
- return;
+ // Don't try mine blocks unless we're at the top of chain and have at least three p2p connections.
+ fTrySync = false;
+ if (vNodes.size() < 3 || nBestHeight < GetNumBlocksOfPeers())
+ {
+ Sleep(1000);
+ continue;
+ }
}
- // Now we have new coinstake, it's time to create the block ...
- CBlock* pblock;
- pblock = CreateNewBlock(pwallet, &txCoinStake);
- if (!pblock)
+ if (ScanMap(inputsMap, nBits, LuckyInput, solution))
{
- string strMessage = _("Warning: Unable to allocate memory for the new block object. Mining thread has been stopped.");
- strMiscWarning = strMessage;
- printf("*** %s\n", strMessage.c_str());
+ SetThreadPriority(THREAD_PRIORITY_NORMAL);
- return;
- }
+ // Remove lucky input from the map
+ inputsMap.erase(inputsMap.find(LuckyInput));
- unsigned int nExtraNonce = 0;
- IncrementExtraNonce(pblock, pindexPrev, nExtraNonce);
+ CKey key;
+ CTransaction txCoinStake;
- // ... and sign it
- if (!key.Sign(pblock->GetHash(), pblock->vchBlockSig))
- {
- string strMessage = _("Warning: Proof-of-Stake miner is unable to sign the block (locked wallet?). Mining thread has been stopped.");
- strMiscWarning = strMessage;
- printf("*** %s\n", strMessage.c_str());
+ // Create new coinstake transaction
+ if (!pwallet->CreateCoinStake(LuckyInput.first, LuckyInput.second, solution.second, nBits, txCoinStake, key))
+ {
+ string strMessage("Warning: Unable to create coinstake transaction, see debug.log for the details. Mining thread has been stopped.");
+ strMiscWarning = strMessage;
+ printf("*** %s\n", strMessage.c_str());
- return;
- }
+ break;
+ }
- CheckStake(pblock, *pwallet);
- SetThreadPriority(THREAD_PRIORITY_LOWEST);
- Sleep(500);
- }
+ // Now we have new coinstake, it's time to create the block ...
+ auto pblock = CreateNewBlock(pwallet, &txCoinStake);
+ if (!pblock)
+ {
+ string strMessage("Warning: Unable to allocate memory for the new block object. Mining thread has been stopped.");
+ strMiscWarning = strMessage;
+ printf("*** %s\n", strMessage.c_str());
- if (pindexPrev != pindexBest)
- {
- // The best block has been changed, we need to refill the map
- if (FillMap(pwallet, GetAdjustedTime(), inputsMap))
- {
- pindexPrev = pindexBest;
- nBits = GetNextTargetRequired(pindexPrev, true);
+ break;
+ }
+
+ unsigned int nExtraNonce = 0;
+ IncrementExtraNonce(pblock, pindexPrev, nExtraNonce);
+
+ // ... and sign it
+ if (!key.Sign(pblock->GetHash(), pblock->vchBlockSig))
+ {
+ string strMessage("Warning: Proof-of-Stake miner is unable to sign the block (locked wallet?). Mining thread has been stopped.");
+ strMiscWarning = strMessage;
+ printf("*** %s\n", strMessage.c_str());
+
+ break;
+ }
+
+ CheckStake(pblock, *pwallet);
+ SetThreadPriority(THREAD_PRIORITY_LOWEST);
+ Sleep(500);
}
- else
+
+ if (pindexPrev != pindexBest)
{
- // Clear existent data if FillMap failed
- inputsMap.clear();
+ // The best block has been changed, we need to refill the map
+ if (FillMap(pwallet, GetAdjustedTime(), inputsMap))
+ {
+ pindexPrev = pindexBest;
+ nBits = GetNextTargetRequired(pindexPrev, true);
+ }
+ else
+ {
+ // Clear existent data if FillMap failed
+ inputsMap.clear();
+ }
}
- }
- Sleep(500);
+ Sleep(500);
+
+ _endloop:
+ (void)0; // do nothing
+ }
+ while(!fShutdown);
- continue;
+ vnThreadsRunning[THREAD_MINTER]--;
+ }
+ catch (exception& e) {
+ vnThreadsRunning[THREAD_MINTER]--;
+ PrintException(&e, "ThreadStakeMinter()");
+ } catch (...) {
+ vnThreadsRunning[THREAD_MINTER]--;
+ PrintException(NULL, "ThreadStakeMinter()");
}
+ printf("ThreadStakeMinter exiting, %d threads remaining\n", vnThreadsRunning[THREAD_MINTER]);
}
git://git.novaco.in / novacoin.git / blobdiff