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

144
src/addrman.h
View File

@ -245,9 +245,6 @@ protected:
void Connected_(const CService &addr, int64_t nTime); void Connected_(const CService &addr, int64_t nTime);
public: public:
IMPLEMENT_SERIALIZE
(({
// serialized format: // serialized format:
// * version byte (currently 0) // * version byte (currently 0)
// * nKey // * nKey
@ -268,117 +265,122 @@ public:
// //
// This format is more complex, but significantly smaller (at most 1.5 MiB), and supports // 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. // 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); LOCK(cs);
unsigned char nVersion = 0;
READWRITE(nVersion);
READWRITE(nKey);
READWRITE(nNew);
READWRITE(nTried);
CAddrMan *am = const_cast<CAddrMan*>(this); unsigned char nVersion = 0;
if (fWrite) s << nVersion;
{ s << nKey;
s << nNew;
s << nTried;
int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT; int nUBuckets = ADDRMAN_NEW_BUCKET_COUNT;
READWRITE(nUBuckets); s << nUBuckets;
std::map<int, int> mapUnkIds; std::map<int, int> mapUnkIds;
int nIds = 0; int nIds = 0;
for (std::map<int, CAddrInfo>::iterator it = am->mapInfo.begin(); it != am->mapInfo.end(); it++) 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 if (nIds == nNew) break; // this means nNew was wrong, oh ow
mapUnkIds[(*it).first] = nIds; mapUnkIds[(*it).first] = nIds;
CAddrInfo &info = (*it).second; const CAddrInfo &info = (*it).second;
if (info.nRefCount) if (info.nRefCount) {
{ s << info;
READWRITE(info);
nIds++; nIds++;
} }
} }
nIds = 0; nIds = 0;
for (std::map<int, CAddrInfo>::iterator it = am->mapInfo.begin(); it != am->mapInfo.end(); it++) 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 if (nIds == nTried) break; // this means nTried was wrong, oh ow
CAddrInfo &info = (*it).second; const CAddrInfo &info = (*it).second;
if (info.fInTried) if (info.fInTried) {
{ s << info;
READWRITE(info);
nIds++; nIds++;
} }
} }
for (std::vector<std::set<int> >::iterator it = am->vvNew.begin(); it != am->vvNew.end(); it++) for (std::vector<std::set<int> >::const_iterator it = vvNew.begin(); it != vvNew.end(); it++) {
{
const std::set<int> &vNew = (*it); const std::set<int> &vNew = (*it);
int nSize = vNew.size(); int nSize = vNew.size();
READWRITE(nSize); s << nSize;
for (std::set<int>::iterator it2 = vNew.begin(); it2 != vNew.end(); it2++) for (std::set<int>::const_iterator it2 = vNew.begin(); it2 != vNew.end(); it2++) {
{
int nIndex = mapUnkIds[*it2]; int nIndex = mapUnkIds[*it2];
READWRITE(nIndex); s << nIndex;
} }
} }
} else { }
template<typename Stream>
void Unserialize(Stream& s, int nType, int nVersionDummy)
{
LOCK(cs);
unsigned char nVersion;
s >> nVersion;
s >> nKey;
s >> nNew;
s >> nTried;
int nUBuckets = 0; int nUBuckets = 0;
READWRITE(nUBuckets); s >> nUBuckets;
am->nIdCount = 0; nIdCount = 0;
am->mapInfo.clear(); mapInfo.clear();
am->mapAddr.clear(); mapAddr.clear();
am->vRandom.clear(); vRandom.clear();
am->vvTried = std::vector<std::vector<int> >(ADDRMAN_TRIED_BUCKET_COUNT, std::vector<int>(0)); vvTried = std::vector<std::vector<int> >(ADDRMAN_TRIED_BUCKET_COUNT, std::vector<int>(0));
am->vvNew = std::vector<std::set<int> >(ADDRMAN_NEW_BUCKET_COUNT, std::set<int>()); vvNew = std::vector<std::set<int> >(ADDRMAN_NEW_BUCKET_COUNT, std::set<int>());
for (int n = 0; n < am->nNew; n++) for (int n = 0; n < nNew; n++) {
{ CAddrInfo &info = mapInfo[n];
CAddrInfo &info = am->mapInfo[n]; s >> info;
READWRITE(info); mapAddr[info] = n;
am->mapAddr[info] = n;
info.nRandomPos = vRandom.size(); info.nRandomPos = vRandom.size();
am->vRandom.push_back(n); vRandom.push_back(n);
if (nUBuckets != ADDRMAN_NEW_BUCKET_COUNT) if (nUBuckets != ADDRMAN_NEW_BUCKET_COUNT) {
{ vvNew[info.GetNewBucket(nKey)].insert(n);
am->vvNew[info.GetNewBucket(am->nKey)].insert(n);
info.nRefCount++; info.nRefCount++;
} }
} }
am->nIdCount = am->nNew; nIdCount = nNew;
int nLost = 0; int nLost = 0;
for (int n = 0; n < am->nTried; n++) for (int n = 0; n < nTried; n++) {
{
CAddrInfo info; CAddrInfo info;
READWRITE(info); s >> info;
std::vector<int> &vTried = am->vvTried[info.GetTriedBucket(am->nKey)]; std::vector<int> &vTried = vvTried[info.GetTriedBucket(nKey)];
if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE) if (vTried.size() < ADDRMAN_TRIED_BUCKET_SIZE) {
{
info.nRandomPos = vRandom.size(); info.nRandomPos = vRandom.size();
info.fInTried = true; info.fInTried = true;
am->vRandom.push_back(am->nIdCount); vRandom.push_back(nIdCount);
am->mapInfo[am->nIdCount] = info; mapInfo[nIdCount] = info;
am->mapAddr[info] = am->nIdCount; mapAddr[info] = nIdCount;
vTried.push_back(am->nIdCount); vTried.push_back(nIdCount);
am->nIdCount++; nIdCount++;
} else { } else {
nLost++; nLost++;
} }
} }
am->nTried -= nLost; nTried -= nLost;
for (int b = 0; b < nUBuckets; b++) for (int b = 0; b < nUBuckets; b++) {
{ std::set<int> &vNew = vvNew[b];
std::set<int> &vNew = am->vvNew[b];
int nSize = 0; int nSize = 0;
READWRITE(nSize); s >> nSize;
for (int n = 0; n < nSize; n++) for (int n = 0; n < nSize; n++) {
{
int nIndex = 0; int nIndex = 0;
READWRITE(nIndex); s >> nIndex;
CAddrInfo &info = am->mapInfo[nIndex]; CAddrInfo &info = mapInfo[nIndex];
if (nUBuckets == ADDRMAN_NEW_BUCKET_COUNT && info.nRefCount < ADDRMAN_NEW_BUCKETS_PER_ADDRESS) if (nUBuckets == ADDRMAN_NEW_BUCKET_COUNT && info.nRefCount < ADDRMAN_NEW_BUCKETS_PER_ADDRESS) {
{
info.nRefCount++; info.nRefCount++;
vNew.insert(nIndex); 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.