boxtec
/
bitcoin
mirror of https://github.com/bitcoin/bitcoin
4
1
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #4508

Browse Source 
b069750 Break up CAddrMan's IMPLEMENT_SERIALIZE (Pieter Wuille)
pull/4813/head
Pieter Wuille 10 years ago
parent c4f11ca9c3 b069750d3f
commit fb203cab40
No known key found for this signature in database
GPG Key ID: 8F653255C87992E0
2 changed files with 160 additions and 129 deletions
Show Stats Download Patch File Download Diff File

260
src/addrman.h
Unescape View File

@ -245,140 +245,142 @@ protected:
void Connected_(const CService &addr, int64_t nTime); void Connected_(const CService &addr, int64_t nTime);
public: public:
// serialized format:
// * version byte (currently 0)
// * nKey
// * nNew
// * nTried
// * number of "new" buckets
// * all nNew addrinfos in vvNew
// * all nTried addrinfos in vvTried
// * for each bucket:
// * number of elements
// * for each element: index
//
// Notice that vvTried, mapAddr and vVector are never encoded explicitly;
// they are instead reconstructed from the other information.
//
// vvNew is serialized, but only used if ADDRMAN_UNKOWN_BUCKET_COUNT didn't change,
// otherwise it is reconstructed as well.
//
// This format is more complex, but significantly smaller (at most 1.5 MiB), and supports
// changes to the ADDRMAN_ parameters without breaking the on-disk structure.
//
// We don't use IMPLEMENT_SERIALIZE since the serialization and deserialization code has
// very little in common.
template<typename Stream>
void Serialize(Stream &s, int nType, int nVersionDummy) const
{
LOCK(cs);
unsigned char nVersion = 0;
s << nVersion;
s << nKey;
s << nNew;
s << nTried;
int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT;
s << nUBuckets;
std::map<int, int> mapUnkIds;
int nIds = 0;
for (std::map<int, CAddrInfo>::const_iterator it = mapInfo.begin(); it != mapInfo.end(); it++) {
if (nIds == nNew) break; // this means nNew was wrong, oh ow
mapUnkIds[(*it).first] = nIds;
const CAddrInfo &info = (*it).second;
if (info.nRefCount) {
s << info;
nIds++;
}
}
nIds = 0;
for (std::map<int, CAddrInfo>::const_iterator it = mapInfo.begin(); it != mapInfo.end(); it++) {
if (nIds == nTried) break; // this means nTried was wrong, oh ow
const CAddrInfo &info = (*it).second;
if (info.fInTried) {
s << info;
nIds++;
}
}
for (std::vector<std::set<int> >::const_iterator it = vvNew.begin(); it != vvNew.end(); it++) {
const std::set<int> &vNew = (*it);
int nSize = vNew.size();
s << nSize;
for (std::set<int>::const_iterator it2 = vNew.begin(); it2 != vNew.end(); it2++) {
int nIndex = mapUnkIds[*it2];
s << nIndex;
}
}
}
IMPLEMENT_SERIALIZE template<typename Stream>
(({ void Unserialize(Stream& s, int nType, int nVersionDummy)
// serialized format: {
// * version byte (currently 0) LOCK(cs);
// * nKey
// * nNew unsigned char nVersion;
// * nTried s >> nVersion;
// * number of "new" buckets s >> nKey;
// * all nNew addrinfos in vvNew s >> nNew;
// * all nTried addrinfos in vvTried s >> nTried;
// * for each bucket:
// * number of elements int nUBuckets = 0;
// * for each element: index s >> nUBuckets;
// nIdCount = 0;
// Notice that vvTried, mapAddr and vVector are never encoded explicitly; mapInfo.clear();
// they are instead reconstructed from the other information. mapAddr.clear();
// vRandom.clear();
// vvNew is serialized, but only used if ADDRMAN_UNKOWN_BUCKET_COUNT didn't change, vvTried = std::vector<std::vector<int> >(ADDRMAN_TRIED_BUCKET_COUNT, std::vector<int>(0));
// otherwise it is reconstructed as well. vvNew = std::vector<std::set<int> >(ADDRMAN_NEW_BUCKET_COUNT, std::set<int>());
// for (int n = 0; n < nNew; n++) {
// This format is more complex, but significantly smaller (at most 1.5 MiB), and supports CAddrInfo &info = mapInfo[n];
// changes to the ADDRMAN_ parameters without breaking the on-disk structure. s >> info;
{ mapAddr[info] = n;
LOCK(cs); info.nRandomPos = vRandom.size();
unsigned char nVersion = 0; vRandom.push_back(n);
READWRITE(nVersion); if (nUBuckets != ADDRMAN_NEW_BUCKET_COUNT) {
READWRITE(nKey); vvNew[info.GetNewBucket(nKey)].insert(n);
READWRITE(nNew); info.nRefCount++;
READWRITE(nTried); }
}
CAddrMan *am = const_cast<CAddrMan*>(this); nIdCount = nNew;
if (fWrite) int nLost = 0;
{ for (int n = 0; n < nTried; n++) {
int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT; CAddrInfo info;
READWRITE(nUBuckets); s >> info;
std::map<int, int> mapUnkIds; std::vector<int> &vTried = vvTried[info.GetTriedBucket(nKey)];
int nIds = 0; if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE) {
for (std::map<int, CAddrInfo>::iterator it = am->mapInfo.begin(); it != am->mapInfo.end(); it++) info.nRandomPos = vRandom.size();
{ info.fInTried = true;
if (nIds == nNew) break; // this means nNew was wrong, oh ow vRandom.push_back(nIdCount);
mapUnkIds[(*it).first] = nIds; mapInfo[nIdCount] = info;
CAddrInfo &info = (*it).second; mapAddr[info] = nIdCount;
if (info.nRefCount) vTried.push_back(nIdCount);
{ nIdCount++;
READWRITE(info);
nIds++;
}
}
nIds = 0;
for (std::map<int, CAddrInfo>::iterator it = am->mapInfo.begin(); it != am->mapInfo.end(); it++)
{
if (nIds == nTried) break; // this means nTried was wrong, oh ow
CAddrInfo &info = (*it).second;
if (info.fInTried)
{
READWRITE(info);
nIds++;
}
}
for (std::vector<std::set<int> >::iterator it = am->vvNew.begin(); it != am->vvNew.end(); it++)
{
const std::set<int> &vNew = (*it);
int nSize = vNew.size();
READWRITE(nSize);
for (std::set<int>::iterator it2 = vNew.begin(); it2 != vNew.end(); it2++)
{
int nIndex = mapUnkIds[*it2];
READWRITE(nIndex);
}
}
} else { } else {
int nUBuckets = 0; nLost++;
READWRITE(nUBuckets); }
am->nIdCount = 0; }
am->mapInfo.clear(); nTried -= nLost;
am->mapAddr.clear(); for (int b = 0; b < nUBuckets; b++) {
am->vRandom.clear(); std::set<int> &vNew = vvNew[b];
am->vvTried = std::vector<std::vector<int> >(ADDRMAN_TRIED_BUCKET_COUNT, std::vector<int>(0)); int nSize = 0;
am->vvNew = std::vector<std::set<int> >(ADDRMAN_NEW_BUCKET_COUNT, std::set<int>()); s >> nSize;
for (int n = 0; n < am->nNew; n++) for (int n = 0; n < nSize; n++) {
{ int nIndex = 0;
CAddrInfo &info = am->mapInfo[n]; s >> nIndex;
READWRITE(info); CAddrInfo &info = mapInfo[nIndex];
am->mapAddr[info] = n; if (nUBuckets == ADDRMAN_NEW_BUCKET_COUNT && info.nRefCount < ADDRMAN_NEW_BUCKETS_PER_ADDRESS) {
info.nRandomPos = vRandom.size(); info.nRefCount++;
am->vRandom.push_back(n); vNew.insert(nIndex);
if (nUBuckets != ADDRMAN_NEW_BUCKET_COUNT)
{
am->vvNew[info.GetNewBucket(am->nKey)].insert(n);
info.nRefCount++;
}
}
am->nIdCount = am->nNew;
int nLost = 0;
for (int n = 0; n < am->nTried; n++)
{
CAddrInfo info;
READWRITE(info);
std::vector<int> &vTried = am->vvTried[info.GetTriedBucket(am->nKey)];
if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE)
{
info.nRandomPos = vRandom.size();
info.fInTried = true;
am->vRandom.push_back(am->nIdCount);
am->mapInfo[am->nIdCount] = info;
am->mapAddr[info] = am->nIdCount;
vTried.push_back(am->nIdCount);
am->nIdCount++;
} else {
nLost++;
}
}
am->nTried -= nLost;
for (int b = 0; b < nUBuckets; b++)
{
std::set<int> &vNew = am->vvNew[b];
int nSize = 0;
READWRITE(nSize);
for (int n = 0; n < nSize; n++)
{
int nIndex = 0;
READWRITE(nIndex);
CAddrInfo &info = am->mapInfo[nIndex];
if (nUBuckets == ADDRMAN_NEW_BUCKET_COUNT && info.nRefCount < ADDRMAN_NEW_BUCKETS_PER_ADDRESS)
{
info.nRefCount++;
vNew.insert(nIndex);
}
}
} }
} }
} }
});) }
unsigned int GetSerializeSize(int nType, int nVersion) const
{
return (CSizeComputer(nType, nVersion) << *this).size();
}
CAddrMan() : vRandom(0), vvTried(ADDRMAN_TRIED_BUCKET_COUNT, std::vector<int>(0)), vvNew(ADDRMAN_NEW_BUCKET_COUNT, std::set<int>()) CAddrMan() : vRandom(0), vvTried(ADDRMAN_TRIED_BUCKET_COUNT, std::vector<int>(0)), vvNew(ADDRMAN_NEW_BUCKET_COUNT, std::set<int>())
{ {

29
src/serialize.h
Unescape View File

@ -830,6 +830,35 @@ struct ser_streamplaceholder
typedef std::vector<char, zero_after_free_allocator<char> > CSerializeData; typedef std::vector<char, zero_after_free_allocator<char> > CSerializeData;
class CSizeComputer
{
protected:
size_t nSize;
public:
int nType;
int nVersion;
CSizeComputer(int nTypeIn, int nVersionIn) : nSize(0), nType(nTypeIn), nVersion(nVersionIn) {}
CSizeComputer& write(const char *psz, int nSize)
{
this->nSize += nSize;
return *this;
}
template<typename T>
CSizeComputer& operator<<(const T& obj)
{
::Serialize(*this, obj, nType, nVersion);
return (*this);
}
size_t size() const {
return nSize;
}
};
/** Double ended buffer combining vector and stream-like interfaces. /** Double ended buffer combining vector and stream-like interfaces.
* *
* >> and << read and write unformatted data using the above serialization templates. * >> and << read and write unformatted data using the above serialization templates.

Write Preview
Loading…
Cancel
Save