* This removes block-size-limiting code in favor of GBT clients
doing the limiting themselves (if at all).
* -blockmaxsize is deprecated and only used to calculate an implied
blockmaxweight, addressing confusion from multiple users.
* getmininginfo's currentblocksize return value was returning
garbage values, and has been removed, also removing a
GetSerializeSize call in some block generation inner loops and
potentially addressing some performance edge cases.
Github-Pull: #11100
Rebased-From: ba206d2c63
tags/v0.15.1
@@ -500,7 +500,7 @@ std::string HelpMessage(HelpMessageMode mode) | |||
strUsage += HelpMessageGroup(_("Block creation options:")); | |||
strUsage += HelpMessageOpt("-blockmaxweight=<n>", strprintf(_("Set maximum BIP141 block weight (default: %d)"), DEFAULT_BLOCK_MAX_WEIGHT)); | |||
strUsage += HelpMessageOpt("-blockmaxsize=<n>", strprintf(_("Set maximum block size in bytes (default: %d)"), DEFAULT_BLOCK_MAX_SIZE)); | |||
strUsage += HelpMessageOpt("-blockmaxsize=<n>", _("Set maximum BIP141 block weight to this * 4. Deprecated, use blockmaxweight")); | |||
strUsage += HelpMessageOpt("-blockmintxfee=<amt>", strprintf(_("Set lowest fee rate (in %s/kB) for transactions to be included in block creation. (default: %s)"), CURRENCY_UNIT, FormatMoney(DEFAULT_BLOCK_MIN_TX_FEE))); | |||
if (showDebug) | |||
strUsage += HelpMessageOpt("-blockversion=<n>", "Override block version to test forking scenarios"); | |||
@@ -802,6 +802,15 @@ void InitParameterInteraction() | |||
if (gArgs.SoftSetBoolArg("-whitelistrelay", true)) | |||
LogPrintf("%s: parameter interaction: -whitelistforcerelay=1 -> setting -whitelistrelay=1\n", __func__); | |||
} | |||
if (gArgs.IsArgSet("-blockmaxsize")) { | |||
unsigned int max_size = gArgs.GetArg("-blockmaxsize", 0); | |||
if (gArgs.SoftSetArg("blockmaxweight", strprintf("%d", max_size * WITNESS_SCALE_FACTOR))) { | |||
LogPrintf("%s: parameter interaction: -blockmaxsize=%d -> setting -blockmaxweight=%d (-blockmaxsize is deprecated!)\n", __func__, max_size, max_size * WITNESS_SCALE_FACTOR); | |||
} else { | |||
LogPrintf("%s: Ignoring blockmaxsize setting which is overridden by blockmaxweight", __func__); | |||
} | |||
} | |||
} | |||
static std::string ResolveErrMsg(const char * const optname, const std::string& strBind) |
@@ -43,7 +43,6 @@ | |||
// its ancestors. | |||
uint64_t nLastBlockTx = 0; | |||
uint64_t nLastBlockSize = 0; | |||
uint64_t nLastBlockWeight = 0; | |||
int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParams, const CBlockIndex* pindexPrev) | |||
@@ -64,7 +63,6 @@ int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consensusParam | |||
BlockAssembler::Options::Options() { | |||
blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE); | |||
nBlockMaxWeight = DEFAULT_BLOCK_MAX_WEIGHT; | |||
nBlockMaxSize = DEFAULT_BLOCK_MAX_SIZE; | |||
} | |||
BlockAssembler::BlockAssembler(const CChainParams& params, const Options& options) : chainparams(params) | |||
@@ -72,10 +70,6 @@ BlockAssembler::BlockAssembler(const CChainParams& params, const Options& option | |||
blockMinFeeRate = options.blockMinFeeRate; | |||
// Limit weight to between 4K and MAX_BLOCK_WEIGHT-4K for sanity: | |||
nBlockMaxWeight = std::max<size_t>(4000, std::min<size_t>(MAX_BLOCK_WEIGHT - 4000, options.nBlockMaxWeight)); | |||
// Limit size to between 1K and MAX_BLOCK_SERIALIZED_SIZE-1K for sanity: | |||
nBlockMaxSize = std::max<size_t>(1000, std::min<size_t>(MAX_BLOCK_SERIALIZED_SIZE - 1000, options.nBlockMaxSize)); | |||
// Whether we need to account for byte usage (in addition to weight usage) | |||
fNeedSizeAccounting = (nBlockMaxSize < MAX_BLOCK_SERIALIZED_SIZE - 1000); | |||
} | |||
static BlockAssembler::Options DefaultOptions(const CChainParams& params) | |||
@@ -85,20 +79,7 @@ static BlockAssembler::Options DefaultOptions(const CChainParams& params) | |||
// If only one is given, only restrict the specified resource. | |||
// If both are given, restrict both. | |||
BlockAssembler::Options options; | |||
options.nBlockMaxWeight = DEFAULT_BLOCK_MAX_WEIGHT; | |||
options.nBlockMaxSize = DEFAULT_BLOCK_MAX_SIZE; | |||
bool fWeightSet = false; | |||
if (gArgs.IsArgSet("-blockmaxweight")) { | |||
options.nBlockMaxWeight = gArgs.GetArg("-blockmaxweight", DEFAULT_BLOCK_MAX_WEIGHT); | |||
options.nBlockMaxSize = MAX_BLOCK_SERIALIZED_SIZE; | |||
fWeightSet = true; | |||
} | |||
if (gArgs.IsArgSet("-blockmaxsize")) { | |||
options.nBlockMaxSize = gArgs.GetArg("-blockmaxsize", DEFAULT_BLOCK_MAX_SIZE); | |||
if (!fWeightSet) { | |||
options.nBlockMaxWeight = options.nBlockMaxSize * WITNESS_SCALE_FACTOR; | |||
} | |||
} | |||
options.nBlockMaxWeight = gArgs.GetArg("-blockmaxweight", DEFAULT_BLOCK_MAX_WEIGHT); | |||
if (gArgs.IsArgSet("-blockmintxfee")) { | |||
CAmount n = 0; | |||
ParseMoney(gArgs.GetArg("-blockmintxfee", ""), n); | |||
@@ -116,7 +97,6 @@ void BlockAssembler::resetBlock() | |||
inBlock.clear(); | |||
// Reserve space for coinbase tx | |||
nBlockSize = 1000; | |||
nBlockWeight = 4000; | |||
nBlockSigOpsCost = 400; | |||
fIncludeWitness = false; | |||
@@ -175,7 +155,6 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc | |||
int64_t nTime1 = GetTimeMicros(); | |||
nLastBlockTx = nBlockTx; | |||
nLastBlockSize = nBlockSize; | |||
nLastBlockWeight = nBlockWeight; | |||
// Create coinbase transaction. | |||
@@ -190,8 +169,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc | |||
pblocktemplate->vchCoinbaseCommitment = GenerateCoinbaseCommitment(*pblock, pindexPrev, chainparams.GetConsensus()); | |||
pblocktemplate->vTxFees[0] = -nFees; | |||
uint64_t nSerializeSize = GetSerializeSize(*pblock, SER_NETWORK, PROTOCOL_VERSION); | |||
LogPrintf("CreateNewBlock(): total size: %u block weight: %u txs: %u fees: %ld sigops %d\n", nSerializeSize, GetBlockWeight(*pblock), nBlockTx, nFees, nBlockSigOpsCost); | |||
LogPrintf("CreateNewBlock(): block weight: %u txs: %u fees: %ld sigops %d\n", GetBlockWeight(*pblock), nBlockTx, nFees, nBlockSigOpsCost); | |||
// Fill in header | |||
pblock->hashPrevBlock = pindexPrev->GetBlockHash(); | |||
@@ -238,22 +216,13 @@ bool BlockAssembler::TestPackage(uint64_t packageSize, int64_t packageSigOpsCost | |||
// - transaction finality (locktime) | |||
// - premature witness (in case segwit transactions are added to mempool before | |||
// segwit activation) | |||
// - serialized size (in case -blockmaxsize is in use) | |||
bool BlockAssembler::TestPackageTransactions(const CTxMemPool::setEntries& package) | |||
{ | |||
uint64_t nPotentialBlockSize = nBlockSize; // only used with fNeedSizeAccounting | |||
for (const CTxMemPool::txiter it : package) { | |||
if (!IsFinalTx(it->GetTx(), nHeight, nLockTimeCutoff)) | |||
return false; | |||
if (!fIncludeWitness && it->GetTx().HasWitness()) | |||
return false; | |||
if (fNeedSizeAccounting) { | |||
uint64_t nTxSize = ::GetSerializeSize(it->GetTx(), SER_NETWORK, PROTOCOL_VERSION); | |||
if (nPotentialBlockSize + nTxSize >= nBlockMaxSize) { | |||
return false; | |||
} | |||
nPotentialBlockSize += nTxSize; | |||
} | |||
} | |||
return true; | |||
} | |||
@@ -263,9 +232,6 @@ void BlockAssembler::AddToBlock(CTxMemPool::txiter iter) | |||
pblock->vtx.emplace_back(iter->GetSharedTx()); | |||
pblocktemplate->vTxFees.push_back(iter->GetFee()); | |||
pblocktemplate->vTxSigOpsCost.push_back(iter->GetSigOpCost()); | |||
if (fNeedSizeAccounting) { | |||
nBlockSize += ::GetSerializeSize(iter->GetTx(), SER_NETWORK, PROTOCOL_VERSION); | |||
} | |||
nBlockWeight += iter->GetTxWeight(); | |||
++nBlockTx; | |||
nBlockSigOpsCost += iter->GetSigOpCost(); |
@@ -139,13 +139,11 @@ private: | |||
// Configuration parameters for the block size | |||
bool fIncludeWitness; | |||
unsigned int nBlockMaxWeight, nBlockMaxSize; | |||
bool fNeedSizeAccounting; | |||
unsigned int nBlockMaxWeight; | |||
CFeeRate blockMinFeeRate; | |||
// Information on the current status of the block | |||
uint64_t nBlockWeight; | |||
uint64_t nBlockSize; | |||
uint64_t nBlockTx; | |||
uint64_t nBlockSigOpsCost; | |||
CAmount nFees; |
@@ -16,8 +16,6 @@ | |||
class CCoinsViewCache; | |||
class CTxOut; | |||
/** Default for -blockmaxsize, which controls the maximum size of block the mining code will create **/ | |||
static const unsigned int DEFAULT_BLOCK_MAX_SIZE = 750000; | |||
/** Default for -blockmaxweight, which controls the range of block weights the mining code will create **/ | |||
static const unsigned int DEFAULT_BLOCK_MAX_WEIGHT = 3000000; | |||
/** Default for -blockmintxfee, which sets the minimum feerate for a transaction in blocks created by mining code **/ |
@@ -195,7 +195,6 @@ UniValue getmininginfo(const JSONRPCRequest& request) | |||
"\nResult:\n" | |||
"{\n" | |||
" \"blocks\": nnn, (numeric) The current block\n" | |||
" \"currentblocksize\": nnn, (numeric) The last block size\n" | |||
" \"currentblockweight\": nnn, (numeric) The last block weight\n" | |||
" \"currentblocktx\": nnn, (numeric) The last block transaction\n" | |||
" \"difficulty\": xxx.xxxxx (numeric) The current difficulty\n" | |||
@@ -214,7 +213,6 @@ UniValue getmininginfo(const JSONRPCRequest& request) | |||
UniValue obj(UniValue::VOBJ); | |||
obj.push_back(Pair("blocks", (int)chainActive.Height())); | |||
obj.push_back(Pair("currentblocksize", (uint64_t)nLastBlockSize)); | |||
obj.push_back(Pair("currentblockweight", (uint64_t)nLastBlockWeight)); | |||
obj.push_back(Pair("currentblocktx", (uint64_t)nLastBlockTx)); | |||
obj.push_back(Pair("difficulty", (double)GetDifficulty())); |
@@ -161,7 +161,6 @@ extern CTxMemPool mempool; | |||
typedef std::unordered_map<uint256, CBlockIndex*, BlockHasher> BlockMap; | |||
extern BlockMap mapBlockIndex; | |||
extern uint64_t nLastBlockTx; | |||
extern uint64_t nLastBlockSize; | |||
extern uint64_t nLastBlockWeight; | |||
extern const std::string strMessageMagic; | |||
extern CWaitableCriticalSection csBestBlock; |
@@ -38,7 +38,6 @@ class MiningTest(BitcoinTestFramework): | |||
mining_info = node.getmininginfo() | |||
assert_equal(mining_info['blocks'], 200) | |||
assert_equal(mining_info['chain'], 'regtest') | |||
assert_equal(mining_info['currentblocksize'], 0) | |||
assert_equal(mining_info['currentblocktx'], 0) | |||
assert_equal(mining_info['currentblockweight'], 0) | |||
assert_equal(mining_info['difficulty'], Decimal('4.656542373906925E-10')) |