mirrors/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-02-21 22:42:04 +01:00
Code Issues Projects Releases Wiki Activity

[move-only] Move CAddrMan function definitions to cpp

Browse source 
In preparation for introducing the pimpl pattern to addrman, move all function
bodies out of the header file.

Review hint: use git diff --color-moved=dimmed-zebra
--color-moved-ws=ignore-all-space
This commit is contained in:
Amiti Uttarwar 2021-09-24 14:14:39 -06:00
parent efa227f5df
commit 5faa7dd6d8
2 changed files with 111 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

99
src/addrman.cpp
View file

@ -119,6 +119,11 @@ CAddrMan::CAddrMan(std::vector<bool> asmap, bool deterministic, int32_t consiste
}
}
CAddrMan::~CAddrMan()
{
nKey.SetNull();
}
template <typename Stream>
void CAddrMan::Serialize(Stream& s_) const
{
@ -1017,3 +1022,97 @@ CAddrInfo CAddrMan::SelectTriedCollision_()
return mapInfo[id_old];
}
size_t CAddrMan::size() const
{
LOCK(cs); // TODO: Cache this in an atomic to avoid this overhead
return vRandom.size();
}
bool CAddrMan::Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty)
{
LOCK(cs);
int nAdd = 0;
Check();
for (std::vector<CAddress>::const_iterator it = vAddr.begin(); it != vAddr.end(); it++)
nAdd += Add_(*it, source, nTimePenalty) ? 1 : 0;
Check();
if (nAdd) {
LogPrint(BCLog::ADDRMAN, "Added %i addresses from %s: %i tried, %i new\n", nAdd, source.ToString(), nTried, nNew);
}
return nAdd > 0;
}
void CAddrMan::Good(const CService &addr, int64_t nTime)
{
LOCK(cs);
Check();
Good_(addr, /* test_before_evict */ true, nTime);
Check();
}
void CAddrMan::Attempt(const CService &addr, bool fCountFailure, int64_t nTime)
{
LOCK(cs);
Check();
Attempt_(addr, fCountFailure, nTime);
Check();
}
void CAddrMan::ResolveCollisions()
{
LOCK(cs);
Check();
ResolveCollisions_();
Check();
}
CAddrInfo CAddrMan::SelectTriedCollision()
{
LOCK(cs);
Check();
const CAddrInfo ret = SelectTriedCollision_();
Check();
return ret;
}
CAddrInfo CAddrMan::Select(bool newOnly) const
{
LOCK(cs);
Check();
const CAddrInfo addrRet = Select_(newOnly);
Check();
return addrRet;
}
std::vector<CAddress> CAddrMan::GetAddr(size_t max_addresses, size_t max_pct, std::optional<Network> network) const
{
LOCK(cs);
Check();
std::vector<CAddress> vAddr;
GetAddr_(vAddr, max_addresses, max_pct, network);
Check();
return vAddr;
}
void CAddrMan::Connected(const CService &addr, int64_t nTime)
{
LOCK(cs);
Check();
Connected_(addr, nTime);
Check();
}
void CAddrMan::SetServices(const CService &addr, ServiceFlags nServices)
{
LOCK(cs);
Check();
SetServices_(addr, nServices);
Check();
}
const std::vector<bool>& CAddrMan::GetAsmap() const
{
return m_asmap;
}

99
src/addrman.h
View file

@ -150,88 +150,33 @@ public:
explicit CAddrMan(std::vector<bool> asmap, bool deterministic, int32_t consistency_check_ratio);
~CAddrMan()
{
nKey.SetNull();
}
~CAddrMan();
//! Return the number of (unique) addresses in all tables.
size_t size() const
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs); // TODO: Cache this in an atomic to avoid this overhead
return vRandom.size();
}
size_t size() const EXCLUSIVE_LOCKS_REQUIRED(!cs);
//! Add addresses to addrman's new table.
bool Add(const std::vector<CAddress> &vAddr, const CNetAddr& source, int64_t nTimePenalty = 0)
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs);
int nAdd = 0;
Check();
for (std::vector<CAddress>::const_iterator it = vAddr.begin(); it != vAddr.end(); it++)
nAdd += Add_(*it, source, nTimePenalty) ? 1 : 0;
Check();
if (nAdd) {
LogPrint(BCLog::ADDRMAN, "Added %i addresses from %s: %i tried, %i new\n", nAdd, source.ToString(), nTried, nNew);
}
return nAdd > 0;
}
EXCLUSIVE_LOCKS_REQUIRED(!cs);
//! Mark an entry as accessible.
void Good(const CService &addr, int64_t nTime = GetAdjustedTime())
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs);
Check();
Good_(addr, /* test_before_evict */ true, nTime);
Check();
}
EXCLUSIVE_LOCKS_REQUIRED(!cs);
//! Mark an entry as connection attempted to.
void Attempt(const CService &addr, bool fCountFailure, int64_t nTime = GetAdjustedTime())
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs);
Check();
Attempt_(addr, fCountFailure, nTime);
Check();
}
EXCLUSIVE_LOCKS_REQUIRED(!cs);
//! See if any to-be-evicted tried table entries have been tested and if so resolve the collisions.
void ResolveCollisions()
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs);
Check();
ResolveCollisions_();
Check();
}
void ResolveCollisions() EXCLUSIVE_LOCKS_REQUIRED(!cs);
//! Randomly select an address in tried that another address is attempting to evict.
CAddrInfo SelectTriedCollision()
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs);
Check();
const CAddrInfo ret = SelectTriedCollision_();
Check();
return ret;
}
CAddrInfo SelectTriedCollision() EXCLUSIVE_LOCKS_REQUIRED(!cs);
/**
* Choose an address to connect to.
*/
CAddrInfo Select(bool newOnly = false) const
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs);
Check();
const CAddrInfo addrRet = Select_(newOnly);
Check();
return addrRet;
}
CAddrInfo Select(bool newOnly = false) const EXCLUSIVE_LOCKS_REQUIRED(!cs);
/**
* Return all or many randomly selected addresses, optionally by network.
@ -241,36 +186,16 @@ public:
* @param[in] network Select only addresses of this network (nullopt = all).
*/
std::vector<CAddress> GetAddr(size_t max_addresses, size_t max_pct, std::optional<Network> network) const
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs);
Check();
std::vector<CAddress> vAddr;
GetAddr_(vAddr, max_addresses, max_pct, network);
Check();
return vAddr;
}
EXCLUSIVE_LOCKS_REQUIRED(!cs);
//! Outer function for Connected_()
void Connected(const CService &addr, int64_t nTime = GetAdjustedTime())
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs);
Check();
Connected_(addr, nTime);
Check();
}
EXCLUSIVE_LOCKS_REQUIRED(!cs);
void SetServices(const CService &addr, ServiceFlags nServices)
EXCLUSIVE_LOCKS_REQUIRED(!cs)
{
LOCK(cs);
Check();
SetServices_(addr, nServices);
Check();
}
EXCLUSIVE_LOCKS_REQUIRED(!cs);
const std::vector<bool>& GetAsmap() const { return m_asmap; }
const std::vector<bool>& GetAsmap() const;
private:
//! A mutex to protect the inner data structures.