foster/bitcoin-core
0
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-03-05 14:06:27 -05:00
Code Issues Activity

scripted-diff: rename vBlockHashesToAnnounce and vInventoryBlockToSend

Browse source 
-BEGIN VERIFY SCRIPT-
sed -i 's/vBlockHashesToAnnounce/m_blocks_for_headers_relay/g' src/net_processing.*
sed -i 's/vInventoryBlockToSend/m_blocks_for_inv_relay/g' src/net_processing.*
-END VERIFY SCRIPT-
This commit is contained in:
John Newbery 2020-06-16 16:27:34 -04:00
parent 53b7ac1b7d
commit c853ef002e
2 changed files with 16 additions and 16 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
src/net_processing.cpp
View file

@ -1321,7 +1321,7 @@ void PeerManager::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockInde
Peer& peer = *it.second; Peer& peer = *it.second;
LOCK(peer.m_block_inv_mutex); LOCK(peer.m_block_inv_mutex);
for (const uint256& hash : reverse_iterate(vHashes)) { for (const uint256& hash : reverse_iterate(vHashes)) {
peer.vBlockHashesToAnnounce.push_back(hash); peer.m_blocks_for_headers_relay.push_back(hash);
} }
} }
} }
@ -2799,7 +2799,7 @@ void PeerManager::ProcessMessage(CNode& pfrom, const std::string& msg_type, CDat
LogPrint(BCLog::NET, " getblocks stopping, pruned or too old block at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString()); LogPrint(BCLog::NET, " getblocks stopping, pruned or too old block at %d %s\n", pindex->nHeight, pindex->GetBlockHash().ToString());
break; break;
} }
WITH_LOCK(peer->m_block_inv_mutex, peer->vInventoryBlockToSend.push_back(pindex->GetBlockHash())); WITH_LOCK(peer->m_block_inv_mutex, peer->m_blocks_for_inv_relay.push_back(pindex->GetBlockHash()));
if (--nLimit <= 0) if (--nLimit <= 0)
{ {
// When this block is requested, we'll send an inv that'll // When this block is requested, we'll send an inv that'll
@ -4225,8 +4225,8 @@ bool PeerManager::SendMessages(CNode* pto)
LOCK(peer->m_block_inv_mutex); LOCK(peer->m_block_inv_mutex);
std::vector<CBlock> vHeaders; std::vector<CBlock> vHeaders;
bool fRevertToInv = ((!state.fPreferHeaders && bool fRevertToInv = ((!state.fPreferHeaders &&
(!state.fPreferHeaderAndIDs || peer->vBlockHashesToAnnounce.size() > 1)) || (!state.fPreferHeaderAndIDs || peer->m_blocks_for_headers_relay.size() > 1)) ||
peer->vBlockHashesToAnnounce.size() > MAX_BLOCKS_TO_ANNOUNCE); peer->m_blocks_for_headers_relay.size() > MAX_BLOCKS_TO_ANNOUNCE);
const CBlockIndex *pBestIndex = nullptr; // last header queued for delivery const CBlockIndex *pBestIndex = nullptr; // last header queued for delivery
ProcessBlockAvailability(pto->GetId()); // ensure pindexBestKnownBlock is up-to-date ProcessBlockAvailability(pto->GetId()); // ensure pindexBestKnownBlock is up-to-date
@ -4235,7 +4235,7 @@ bool PeerManager::SendMessages(CNode* pto)
// Try to find first header that our peer doesn't have, and // Try to find first header that our peer doesn't have, and
// then send all headers past that one. If we come across any // then send all headers past that one. If we come across any
// headers that aren't on ::ChainActive(), give up. // headers that aren't on ::ChainActive(), give up.
for (const uint256& hash : peer->vBlockHashesToAnnounce) { for (const uint256& hash : peer->m_blocks_for_headers_relay) {
const CBlockIndex* pindex = LookupBlockIndex(hash); const CBlockIndex* pindex = LookupBlockIndex(hash);
assert(pindex); assert(pindex);
if (::ChainActive()[pindex->nHeight] != pindex) { if (::ChainActive()[pindex->nHeight] != pindex) {
@ -4252,7 +4252,7 @@ bool PeerManager::SendMessages(CNode* pto)
// which should be caught by the prior check), but one // which should be caught by the prior check), but one
// way this could happen is by using invalidateblock / // way this could happen is by using invalidateblock /
// reconsiderblock repeatedly on the tip, causing it to // reconsiderblock repeatedly on the tip, causing it to
// be added multiple times to vBlockHashesToAnnounce. // be added multiple times to m_blocks_for_headers_relay.
// Robustly deal with this rare situation by reverting // Robustly deal with this rare situation by reverting
// to an inv. // to an inv.
fRevertToInv = true; fRevertToInv = true;
@ -4324,10 +4324,10 @@ bool PeerManager::SendMessages(CNode* pto)
} }
if (fRevertToInv) { if (fRevertToInv) {
// If falling back to using an inv, just try to inv the tip. // If falling back to using an inv, just try to inv the tip.
// The last entry in vBlockHashesToAnnounce was our tip at some point // The last entry in m_blocks_for_headers_relay was our tip at some point
// in the past. // in the past.
if (!peer->vBlockHashesToAnnounce.empty()) { if (!peer->m_blocks_for_headers_relay.empty()) {
const uint256& hashToAnnounce = peer->vBlockHashesToAnnounce.back(); const uint256& hashToAnnounce = peer->m_blocks_for_headers_relay.back();
const CBlockIndex* pindex = LookupBlockIndex(hashToAnnounce); const CBlockIndex* pindex = LookupBlockIndex(hashToAnnounce);
assert(pindex); assert(pindex);
@ -4341,13 +4341,13 @@ bool PeerManager::SendMessages(CNode* pto)
// If the peer's chain has this block, don't inv it back. // If the peer's chain has this block, don't inv it back.
if (!PeerHasHeader(&state, pindex)) { if (!PeerHasHeader(&state, pindex)) {
peer->vInventoryBlockToSend.push_back(hashToAnnounce); peer->m_blocks_for_inv_relay.push_back(hashToAnnounce);
LogPrint(BCLog::NET, "%s: sending inv peer=%d hash=%s\n", __func__, LogPrint(BCLog::NET, "%s: sending inv peer=%d hash=%s\n", __func__,
pto->GetId(), hashToAnnounce.ToString()); pto->GetId(), hashToAnnounce.ToString());
} }
} }
} }
peer->vBlockHashesToAnnounce.clear(); peer->m_blocks_for_headers_relay.clear();
} }
// //
@ -4356,17 +4356,17 @@ bool PeerManager::SendMessages(CNode* pto)
std::vector<CInv> vInv; std::vector<CInv> vInv;
{ {
LOCK(peer->m_block_inv_mutex); LOCK(peer->m_block_inv_mutex);
vInv.reserve(std::max<size_t>(peer->vInventoryBlockToSend.size(), INVENTORY_BROADCAST_MAX)); vInv.reserve(std::max<size_t>(peer->m_blocks_for_inv_relay.size(), INVENTORY_BROADCAST_MAX));
// Add blocks // Add blocks
for (const uint256& hash : peer->vInventoryBlockToSend) { for (const uint256& hash : peer->m_blocks_for_inv_relay) {
vInv.push_back(CInv(MSG_BLOCK, hash)); vInv.push_back(CInv(MSG_BLOCK, hash));
if (vInv.size() == MAX_INV_SZ) { if (vInv.size() == MAX_INV_SZ) {
m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv)); m_connman.PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));
vInv.clear(); vInv.clear();
} }
} }
peer->vInventoryBlockToSend.clear(); peer->m_blocks_for_inv_relay.clear();
if (pto->m_tx_relay != nullptr) { if (pto->m_tx_relay != nullptr) {
LOCK(pto->m_tx_relay->cs_tx_inventory); LOCK(pto->m_tx_relay->cs_tx_inventory);

4
src/net_processing.h
View file

@ -68,11 +68,11 @@ struct Peer {
/** List of blocks that we'll anounce via an `inv` message. /** List of blocks that we'll anounce via an `inv` message.
* There is no final sorting before sending, as they are always sent * There is no final sorting before sending, as they are always sent
* immediately and in the order requested. */ * immediately and in the order requested. */
std::vector<uint256> vInventoryBlockToSend GUARDED_BY(m_block_inv_mutex); std::vector<uint256> m_blocks_for_inv_relay GUARDED_BY(m_block_inv_mutex);
/** Unfiltered list of blocks that we'd like to announce via a `headers` /** Unfiltered list of blocks that we'd like to announce via a `headers`
* message. If we can't announce via a `headers` message, we'll fall back to * message. If we can't announce via a `headers` message, we'll fall back to
* announcing via `inv`. */ * announcing via `inv`. */
std::vector<uint256> vBlockHashesToAnnounce GUARDED_BY(m_block_inv_mutex); std::vector<uint256> m_blocks_for_headers_relay GUARDED_BY(m_block_inv_mutex);
/** This peer's reported block height when we connected */ /** This peer's reported block height when we connected */
std::atomic<int> m_starting_height{-1}; std::atomic<int> m_starting_height{-1};