kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #4508 

b069750 Break up CAddrMan's IMPLEMENT_SERIALIZE (Pieter Wuille)
0.10
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
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 260
      src/addrman.h
  2. 29
      src/serialize.h

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