Skip to content

Commit c4aa2ba

Browse files
sdaftuarsdaftuar
committed
[refactor] Change tx_relay structure to be unique_ptr
1 parent 4de0dba commit c4aa2ba

File tree

3 files changed

+66
-65
lines changed

3 files changed

+66
-65
lines changed

‎src/net.cpp

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -500,8 +500,8 @@ void CNode::copyStats(CNodeStats &stats)
500500
X(addr);
501501
X(addrBind);
502502
{
503-
LOCK(m_tx_relay.cs_filter);
504-
stats.fRelayTxes = m_tx_relay.fRelayTxes;
503+
LOCK(m_tx_relay->cs_filter);
504+
stats.fRelayTxes = m_tx_relay->fRelayTxes;
505505
}
506506
X(nLastSend);
507507
X(nLastRecv);
@@ -529,8 +529,8 @@ void CNode::copyStats(CNodeStats &stats)
529529
X(m_legacyWhitelisted);
530530
X(m_permissionFlags);
531531
{
532-
LOCK(m_tx_relay.cs_feeFilter);
533-
stats.minFeeFilter = m_tx_relay.minFeeFilter;
532+
LOCK(m_tx_relay->cs_feeFilter);
533+
stats.minFeeFilter = m_tx_relay->minFeeFilter;
534534
}
535535

536536
// It is common for nodes with good ping times to suddenly become lagged,
@@ -818,11 +818,11 @@ bool CConnman::AttemptToEvictConnection()
818818
continue;
819819
if (node->fDisconnect)
820820
continue;
821-
LOCK(node->m_tx_relay.cs_filter);
821+
LOCK(node->m_tx_relay->cs_filter);
822822
NodeEvictionCandidate candidate = {node->GetId(), node->nTimeConnected, node->nMinPingUsecTime,
823823
node->nLastBlockTime, node->nLastTXTime,
824824
HasAllDesirableServiceFlags(node->nServices),
825-
node->m_tx_relay.fRelayTxes, node->m_tx_relay.pfilter != nullptr, node->addr, node->nKeyedNetGroup,
825+
node->m_tx_relay->fRelayTxes, node->m_tx_relay->pfilter != nullptr, node->addr, node->nKeyedNetGroup,
826826
node->m_prefer_evict};
827827
vEvictionCandidates.push_back(candidate);
828828
}
@@ -2633,6 +2633,7 @@ CNode::CNode(NodeId idIn, ServiceFlags nLocalServicesIn, int nMyStartingHeightIn
26332633
hSocket = hSocketIn;
26342634
addrName = addrNameIn == "" ? addr.ToStringIPPort() : addrNameIn;
26352635
hashContinue = uint256();
2636+
m_tx_relay = MakeUnique<TxRelay>();
26362637

26372638
for (const std::string &msg : getAllNetMessageTypes())
26382639
mapRecvBytesPerMsgCmd[msg] = 0;

‎src/net.h

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -733,7 +733,7 @@ class CNode
733733
int64_t nextSendTimeFeeFilter{0};
734734
};
735735

736-
TxRelay m_tx_relay;
736+
std::unique_ptr<TxRelay> m_tx_relay;
737737
// Used for headers announcements - unfiltered blocks to relay
738738
std::vector<uint256> vBlockHashesToAnnounce GUARDED_BY(cs_inventory);
739739

@@ -849,17 +849,17 @@ class CNode
849849
void AddInventoryKnown(const CInv& inv)
850850
{
851851
{
852-
LOCK(m_tx_relay.cs_tx_inventory);
853-
m_tx_relay.filterInventoryKnown.insert(inv.hash);
852+
LOCK(m_tx_relay->cs_tx_inventory);
853+
m_tx_relay->filterInventoryKnown.insert(inv.hash);
854854
}
855855
}
856856

857857
void PushInventory(const CInv& inv)
858858
{
859859
if (inv.type == MSG_TX) {
860-
LOCK(m_tx_relay.cs_tx_inventory);
861-
if (!m_tx_relay.filterInventoryKnown.contains(inv.hash)) {
862-
m_tx_relay.setInventoryTxToSend.insert(inv.hash);
860+
LOCK(m_tx_relay->cs_tx_inventory);
861+
if (!m_tx_relay->filterInventoryKnown.contains(inv.hash)) {
862+
m_tx_relay->setInventoryTxToSend.insert(inv.hash);
863863
}
864864
} else if (inv.type == MSG_BLOCK) {
865865
LOCK(cs_inventory);

‎src/net_processing.cpp

Lines changed: 53 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -1449,10 +1449,10 @@ void static ProcessGetBlockData(CNode* pfrom, const CChainParams& chainparams, c
14491449
bool sendMerkleBlock = false;
14501450
CMerkleBlock merkleBlock;
14511451
{
1452-
LOCK(pfrom->m_tx_relay.cs_filter);
1453-
if (pfrom->m_tx_relay.pfilter) {
1452+
LOCK(pfrom->m_tx_relay->cs_filter);
1453+
if (pfrom->m_tx_relay->pfilter) {
14541454
sendMerkleBlock = true;
1455-
merkleBlock = CMerkleBlock(*pblock, *pfrom->m_tx_relay.pfilter);
1455+
merkleBlock = CMerkleBlock(*pblock, *pfrom->m_tx_relay->pfilter);
14561456
}
14571457
}
14581458
if (sendMerkleBlock) {
@@ -1532,11 +1532,11 @@ void static ProcessGetData(CNode* pfrom, const CChainParams& chainparams, CConnm
15321532
if (mi != mapRelay.end()) {
15331533
connman->PushMessage(pfrom, msgMaker.Make(nSendFlags, NetMsgType::TX, *mi->second));
15341534
push = true;
1535-
} else if (pfrom->m_tx_relay.timeLastMempoolReq) {
1535+
} else if (pfrom->m_tx_relay->timeLastMempoolReq) {
15361536
auto txinfo = mempool.info(inv.hash);
15371537
// To protect privacy, do not answer getdata using the mempool when
15381538
// that TX couldn't have been INVed in reply to a MEMPOOL request.
1539-
if (txinfo.tx && txinfo.nTime <= pfrom->m_tx_relay.timeLastMempoolReq) {
1539+
if (txinfo.tx && txinfo.nTime <= pfrom->m_tx_relay->timeLastMempoolReq) {
15401540
connman->PushMessage(pfrom, msgMaker.Make(nSendFlags, NetMsgType::TX, *txinfo.tx));
15411541
push = true;
15421542
}
@@ -1996,8 +1996,8 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
19961996
pfrom->m_limited_node = (!(nServices & NODE_NETWORK) && (nServices & NODE_NETWORK_LIMITED));
19971997

19981998
{
1999-
LOCK(pfrom->m_tx_relay.cs_filter);
2000-
pfrom->m_tx_relay.fRelayTxes = fRelay; // set to true after we get the first filter* message
1999+
LOCK(pfrom->m_tx_relay->cs_filter);
2000+
pfrom->m_tx_relay->fRelayTxes = fRelay; // set to true after we get the first filter* message
20012001
}
20022002

20032003
// Change version
@@ -3030,8 +3030,8 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
30303030
return true;
30313031
}
30323032

3033-
LOCK(pfrom->m_tx_relay.cs_tx_inventory);
3034-
pfrom->m_tx_relay.fSendMempool = true;
3033+
LOCK(pfrom->m_tx_relay->cs_tx_inventory);
3034+
pfrom->m_tx_relay->fSendMempool = true;
30353035
return true;
30363036
}
30373037

@@ -3124,10 +3124,10 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
31243124
}
31253125
else
31263126
{
3127-
LOCK(pfrom->m_tx_relay.cs_filter);
3128-
pfrom->m_tx_relay.pfilter.reset(new CBloomFilter(filter));
3129-
pfrom->m_tx_relay.pfilter->UpdateEmptyFull();
3130-
pfrom->m_tx_relay.fRelayTxes = true;
3127+
LOCK(pfrom->m_tx_relay->cs_filter);
3128+
pfrom->m_tx_relay->pfilter.reset(new CBloomFilter(filter));
3129+
pfrom->m_tx_relay->pfilter->UpdateEmptyFull();
3130+
pfrom->m_tx_relay->fRelayTxes = true;
31313131
}
31323132
return true;
31333133
}
@@ -3142,9 +3142,9 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
31423142
if (vData.size() > MAX_SCRIPT_ELEMENT_SIZE) {
31433143
bad = true;
31443144
} else {
3145-
LOCK(pfrom->m_tx_relay.cs_filter);
3146-
if (pfrom->m_tx_relay.pfilter) {
3147-
pfrom->m_tx_relay.pfilter->insert(vData);
3145+
LOCK(pfrom->m_tx_relay->cs_filter);
3146+
if (pfrom->m_tx_relay->pfilter) {
3147+
pfrom->m_tx_relay->pfilter->insert(vData);
31483148
} else {
31493149
bad = true;
31503150
}
@@ -3157,11 +3157,11 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
31573157
}
31583158

31593159
if (strCommand == NetMsgType::FILTERCLEAR) {
3160-
LOCK(pfrom->m_tx_relay.cs_filter);
3160+
LOCK(pfrom->m_tx_relay->cs_filter);
31613161
if (pfrom->GetLocalServices() & NODE_BLOOM) {
3162-
pfrom->m_tx_relay.pfilter.reset(new CBloomFilter());
3162+
pfrom->m_tx_relay->pfilter.reset(new CBloomFilter());
31633163
}
3164-
pfrom->m_tx_relay.fRelayTxes = true;
3164+
pfrom->m_tx_relay->fRelayTxes = true;
31653165
return true;
31663166
}
31673167

@@ -3170,8 +3170,8 @@ bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStr
31703170
vRecv >> newFeeFilter;
31713171
if (MoneyRange(newFeeFilter)) {
31723172
{
3173-
LOCK(pfrom->m_tx_relay.cs_feeFilter);
3174-
pfrom->m_tx_relay.minFeeFilter = newFeeFilter;
3173+
LOCK(pfrom->m_tx_relay->cs_feeFilter);
3174+
pfrom->m_tx_relay->minFeeFilter = newFeeFilter;
31753175
}
31763176
LogPrint(BCLog::NET, "received: feefilter of %s from peer=%d\n", CFeeRate(newFeeFilter).ToString(), pfrom->GetId());
31773177
}
@@ -3791,70 +3791,70 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
37913791
}
37923792
pto->vInventoryBlockToSend.clear();
37933793

3794-
LOCK(pto->m_tx_relay.cs_tx_inventory);
3794+
LOCK(pto->m_tx_relay->cs_tx_inventory);
37953795
// Check whether periodic sends should happen
37963796
bool fSendTrickle = pto->HasPermission(PF_NOBAN);
3797-
if (pto->m_tx_relay.nNextInvSend < nNow) {
3797+
if (pto->m_tx_relay->nNextInvSend < nNow) {
37983798
fSendTrickle = true;
37993799
if (pto->fInbound) {
3800-
pto->m_tx_relay.nNextInvSend = connman->PoissonNextSendInbound(nNow, INVENTORY_BROADCAST_INTERVAL);
3800+
pto->m_tx_relay->nNextInvSend = connman->PoissonNextSendInbound(nNow, INVENTORY_BROADCAST_INTERVAL);
38013801
} else {
38023802
// Use half the delay for outbound peers, as there is less privacy concern for them.
3803-
pto->m_tx_relay.nNextInvSend = PoissonNextSend(nNow, INVENTORY_BROADCAST_INTERVAL >> 1);
3803+
pto->m_tx_relay->nNextInvSend = PoissonNextSend(nNow, INVENTORY_BROADCAST_INTERVAL >> 1);
38043804
}
38053805
}
38063806

38073807
// Time to send but the peer has requested we not relay transactions.
38083808
if (fSendTrickle) {
3809-
LOCK(pto->m_tx_relay.cs_filter);
3810-
if (!pto->m_tx_relay.fRelayTxes) pto->m_tx_relay.setInventoryTxToSend.clear();
3809+
LOCK(pto->m_tx_relay->cs_filter);
3810+
if (!pto->m_tx_relay->fRelayTxes) pto->m_tx_relay->setInventoryTxToSend.clear();
38113811
}
38123812

38133813
// Respond to BIP35 mempool requests
3814-
if (fSendTrickle && pto->m_tx_relay.fSendMempool) {
3814+
if (fSendTrickle && pto->m_tx_relay->fSendMempool) {
38153815
auto vtxinfo = mempool.infoAll();
3816-
pto->m_tx_relay.fSendMempool = false;
3816+
pto->m_tx_relay->fSendMempool = false;
38173817
CAmount filterrate = 0;
38183818
{
3819-
LOCK(pto->m_tx_relay.cs_feeFilter);
3820-
filterrate = pto->m_tx_relay.minFeeFilter;
3819+
LOCK(pto->m_tx_relay->cs_feeFilter);
3820+
filterrate = pto->m_tx_relay->minFeeFilter;
38213821
}
38223822

3823-
LOCK(pto->m_tx_relay.cs_filter);
3823+
LOCK(pto->m_tx_relay->cs_filter);
38243824

38253825
for (const auto& txinfo : vtxinfo) {
38263826
const uint256& hash = txinfo.tx->GetHash();
38273827
CInv inv(MSG_TX, hash);
3828-
pto->m_tx_relay.setInventoryTxToSend.erase(hash);
3828+
pto->m_tx_relay->setInventoryTxToSend.erase(hash);
38293829
if (filterrate) {
38303830
if (txinfo.feeRate.GetFeePerK() < filterrate)
38313831
continue;
38323832
}
3833-
if (pto->m_tx_relay.pfilter) {
3834-
if (!pto->m_tx_relay.pfilter->IsRelevantAndUpdate(*txinfo.tx)) continue;
3833+
if (pto->m_tx_relay->pfilter) {
3834+
if (!pto->m_tx_relay->pfilter->IsRelevantAndUpdate(*txinfo.tx)) continue;
38353835
}
3836-
pto->m_tx_relay.filterInventoryKnown.insert(hash);
3836+
pto->m_tx_relay->filterInventoryKnown.insert(hash);
38373837
vInv.push_back(inv);
38383838
if (vInv.size() == MAX_INV_SZ) {
38393839
connman->PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));
38403840
vInv.clear();
38413841
}
38423842
}
3843-
pto->m_tx_relay.timeLastMempoolReq = GetTime();
3843+
pto->m_tx_relay->timeLastMempoolReq = GetTime();
38443844
}
38453845

38463846
// Determine transactions to relay
38473847
if (fSendTrickle) {
38483848
// Produce a vector with all candidates for sending
38493849
std::vector<std::set<uint256>::iterator> vInvTx;
3850-
vInvTx.reserve(pto->m_tx_relay.setInventoryTxToSend.size());
3851-
for (std::set<uint256>::iterator it = pto->m_tx_relay.setInventoryTxToSend.begin(); it != pto->m_tx_relay.setInventoryTxToSend.end(); it++) {
3850+
vInvTx.reserve(pto->m_tx_relay->setInventoryTxToSend.size());
3851+
for (std::set<uint256>::iterator it = pto->m_tx_relay->setInventoryTxToSend.begin(); it != pto->m_tx_relay->setInventoryTxToSend.end(); it++) {
38523852
vInvTx.push_back(it);
38533853
}
38543854
CAmount filterrate = 0;
38553855
{
3856-
LOCK(pto->m_tx_relay.cs_feeFilter);
3857-
filterrate = pto->m_tx_relay.minFeeFilter;
3856+
LOCK(pto->m_tx_relay->cs_feeFilter);
3857+
filterrate = pto->m_tx_relay->minFeeFilter;
38583858
}
38593859
// Topologically and fee-rate sort the inventory we send for privacy and priority reasons.
38603860
// A heap is used so that not all items need sorting if only a few are being sent.
@@ -3863,17 +3863,17 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
38633863
// No reason to drain out at many times the network's capacity,
38643864
// especially since we have many peers and some will draw much shorter delays.
38653865
unsigned int nRelayedTransactions = 0;
3866-
LOCK(pto->m_tx_relay.cs_filter);
3866+
LOCK(pto->m_tx_relay->cs_filter);
38673867
while (!vInvTx.empty() && nRelayedTransactions < INVENTORY_BROADCAST_MAX) {
38683868
// Fetch the top element from the heap
38693869
std::pop_heap(vInvTx.begin(), vInvTx.end(), compareInvMempoolOrder);
38703870
std::set<uint256>::iterator it = vInvTx.back();
38713871
vInvTx.pop_back();
38723872
uint256 hash = *it;
38733873
// Remove it from the to-be-sent set
3874-
pto->m_tx_relay.setInventoryTxToSend.erase(it);
3874+
pto->m_tx_relay->setInventoryTxToSend.erase(it);
38753875
// Check if not in the filter already
3876-
if (pto->m_tx_relay.filterInventoryKnown.contains(hash)) {
3876+
if (pto->m_tx_relay->filterInventoryKnown.contains(hash)) {
38773877
continue;
38783878
}
38793879
// Not in the mempool anymore? don't bother sending it.
@@ -3884,7 +3884,7 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
38843884
if (filterrate && txinfo.feeRate.GetFeePerK() < filterrate) {
38853885
continue;
38863886
}
3887-
if (pto->m_tx_relay.pfilter && !pto->m_tx_relay.pfilter->IsRelevantAndUpdate(*txinfo.tx)) continue;
3887+
if (pto->m_tx_relay->pfilter && !pto->m_tx_relay->pfilter->IsRelevantAndUpdate(*txinfo.tx)) continue;
38883888
// Send
38893889
vInv.push_back(CInv(MSG_TX, hash));
38903890
nRelayedTransactions++;
@@ -3905,7 +3905,7 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
39053905
connman->PushMessage(pto, msgMaker.Make(NetMsgType::INV, vInv));
39063906
vInv.clear();
39073907
}
3908-
pto->m_tx_relay.filterInventoryKnown.insert(hash);
3908+
pto->m_tx_relay->filterInventoryKnown.insert(hash);
39093909
}
39103910
}
39113911
}
@@ -4070,23 +4070,23 @@ bool PeerLogicValidation::SendMessages(CNode* pto)
40704070
!pto->HasPermission(PF_FORCERELAY)) {
40714071
CAmount currentFilter = mempool.GetMinFee(gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000).GetFeePerK();
40724072
int64_t timeNow = GetTimeMicros();
4073-
if (timeNow > pto->m_tx_relay.nextSendTimeFeeFilter) {
4073+
if (timeNow > pto->m_tx_relay->nextSendTimeFeeFilter) {
40744074
static CFeeRate default_feerate(DEFAULT_MIN_RELAY_TX_FEE);
40754075
static FeeFilterRounder filterRounder(default_feerate);
40764076
CAmount filterToSend = filterRounder.round(currentFilter);
40774077
// We always have a fee filter of at least minRelayTxFee
40784078
filterToSend = std::max(filterToSend, ::minRelayTxFee.GetFeePerK());
4079-
if (filterToSend != pto->m_tx_relay.lastSentFeeFilter) {
4079+
if (filterToSend != pto->m_tx_relay->lastSentFeeFilter) {
40804080
connman->PushMessage(pto, msgMaker.Make(NetMsgType::FEEFILTER, filterToSend));
4081-
pto->m_tx_relay.lastSentFeeFilter = filterToSend;
4081+
pto->m_tx_relay->lastSentFeeFilter = filterToSend;
40824082
}
4083-
pto->m_tx_relay.nextSendTimeFeeFilter = PoissonNextSend(timeNow, AVG_FEEFILTER_BROADCAST_INTERVAL);
4083+
pto->m_tx_relay->nextSendTimeFeeFilter = PoissonNextSend(timeNow, AVG_FEEFILTER_BROADCAST_INTERVAL);
40844084
}
40854085
// If the fee filter has changed substantially and it's still more than MAX_FEEFILTER_CHANGE_DELAY
40864086
// until scheduled broadcast, then move the broadcast to within MAX_FEEFILTER_CHANGE_DELAY.
4087-
else if (timeNow + MAX_FEEFILTER_CHANGE_DELAY * 1000000 < pto->m_tx_relay.nextSendTimeFeeFilter &&
4088-
(currentFilter < 3 * pto->m_tx_relay.lastSentFeeFilter / 4 || currentFilter > 4 * pto->m_tx_relay.lastSentFeeFilter / 3)) {
4089-
pto->m_tx_relay.nextSendTimeFeeFilter = timeNow + GetRandInt(MAX_FEEFILTER_CHANGE_DELAY) * 1000000;
4087+
else if (timeNow + MAX_FEEFILTER_CHANGE_DELAY * 1000000 < pto->m_tx_relay->nextSendTimeFeeFilter &&
4088+
(currentFilter < 3 * pto->m_tx_relay->lastSentFeeFilter / 4 || currentFilter > 4 * pto->m_tx_relay->lastSentFeeFilter / 3)) {
4089+
pto->m_tx_relay->nextSendTimeFeeFilter = timeNow + GetRandInt(MAX_FEEFILTER_CHANGE_DELAY) * 1000000;
40904090
}
40914091
}
40924092
}

0 commit comments

Comments
 (0)