BTCPrivate
/
BTCP-Rebase
mirror of https://github.com/BTCPrivate/BTCP-Rebase.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #4508 

b069750 Break up CAddrMan's IMPLEMENT_SERIALIZE (Pieter Wuille)
This commit is contained in:
Pieter Wuille 2014-07-17 16:15:52 +02:00
parent c4f11ca9c3 b069750d3f
commit fb203cab40
No known key found for this signature in database
GPG Key ID: 8F653255C87992E0
2 changed files with 159 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

258
src/addrman.h
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);
IMPLEMENT_SERIALIZE unsigned char nVersion = 0;
(({ s << nVersion;
// serialized format: s << nKey;
// * version byte (currently 0) s << nNew;
// * nKey s << nTried;
// * 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.
{
LOCK(cs);
unsigned char nVersion = 0;
READWRITE(nVersion);
READWRITE(nKey);
READWRITE(nNew);
READWRITE(nTried);
CAddrMan *am = const_cast<CAddrMan*>(this); int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT;
if (fWrite) s << nUBuckets;
{ std::map<int, int> mapUnkIds;
int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT; int nIds = 0;
READWRITE(nUBuckets); for (std::map<int, CAddrInfo>::const_iterator it = mapInfo.begin(); it != mapInfo.end(); it++) {
std::map<int, int> mapUnkIds; if (nIds == nNew) break; // this means nNew was wrong, oh ow
int nIds = 0; mapUnkIds[(*it).first] = nIds;
for (std::map<int, CAddrInfo>::iterator it = am->mapInfo.begin(); it != am->mapInfo.end(); it++) const CAddrInfo &info = (*it).second;
{ if (info.nRefCount) {
if (nIds == nNew) break; // this means nNew was wrong, oh ow s << info;
mapUnkIds[(*it).first] = nIds; nIds++;
CAddrInfo &info = (*it).second; }
if (info.nRefCount) }
{ nIds = 0;
READWRITE(info); for (std::map<int, CAddrInfo>::const_iterator it = mapInfo.begin(); it != mapInfo.end(); it++) {
nIds++; if (nIds == nTried) break; // this means nTried was wrong, oh ow
} const CAddrInfo &info = (*it).second;
} if (info.fInTried) {
nIds = 0; s << info;
for (std::map<int, CAddrInfo>::iterator it = am->mapInfo.begin(); it != am->mapInfo.end(); it++) nIds++;
{ }
if (nIds == nTried) break; // this means nTried was wrong, oh ow }
CAddrInfo &info = (*it).second; for (std::vector<std::set<int> >::const_iterator it = vvNew.begin(); it != vvNew.end(); it++) {
if (info.fInTried) const std::set<int> &vNew = (*it);
{ int nSize = vNew.size();
READWRITE(info); s << nSize;
nIds++; for (std::set<int>::const_iterator it2 = vNew.begin(); it2 != vNew.end(); it2++) {
} int nIndex = mapUnkIds[*it2];
} s << nIndex;
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); template<typename Stream>
for (std::set<int>::iterator it2 = vNew.begin(); it2 != vNew.end(); it2++) void Unserialize(Stream& s, int nType, int nVersionDummy)
{ {
int nIndex = mapUnkIds[*it2]; LOCK(cs);
READWRITE(nIndex);
} unsigned char nVersion;
} s >> nVersion;
s >> nKey;
s >> nNew;
s >> nTried;
int nUBuckets = 0;
s >> nUBuckets;
nIdCount = 0;
mapInfo.clear();
mapAddr.clear();
vRandom.clear();
vvTried = std::vector<std::vector<int> >(ADDRMAN_TRIED_BUCKET_COUNT, std::vector<int>(0));
vvNew = std::vector<std::set<int> >(ADDRMAN_NEW_BUCKET_COUNT, std::set<int>());
for (int n = 0; n < nNew; n++) {
CAddrInfo &info = mapInfo[n];
s >> info;
mapAddr[info] = n;
info.nRandomPos = vRandom.size();
vRandom.push_back(n);
if (nUBuckets != ADDRMAN_NEW_BUCKET_COUNT) {
vvNew[info.GetNewBucket(nKey)].insert(n);
info.nRefCount++;
}
}
nIdCount = nNew;
int nLost = 0;
for (int n = 0; n < nTried; n++) {
CAddrInfo info;
s >> info;
std::vector<int> &vTried = vvTried[info.GetTriedBucket(nKey)];
if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE) {
info.nRandomPos = vRandom.size();
info.fInTried = true;
vRandom.push_back(nIdCount);
mapInfo[nIdCount] = info;
mapAddr[info] = nIdCount;
vTried.push_back(nIdCount);
nIdCount++;
} 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
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.