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

Break up CAddrMan's IMPLEMENT_SERIALIZE

0.10
Pieter Wuille 11 years ago committed by Pieter Wuille
parent
87e40799fd
commit
b069750d3f
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. 142
      src/addrman.h
  2. 29
      src/serialize.h

142
src/addrman.h
Unescape 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; unsigned char nVersion = 0;
READWRITE(nVersion); s << nVersion;
READWRITE(nKey); s << nKey;
READWRITE(nNew); s << nNew;
READWRITE(nTried); s << nTried;
CAddrMan *am = const_cast<CAddrMan*>(this);
if (fWrite)
{
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 { }
int nUBuckets = 0;
READWRITE(nUBuckets); template<typename Stream>
am->nIdCount = 0; void Unserialize(Stream& s, int nType, int nVersionDummy)
am->mapInfo.clear();
am->mapAddr.clear();
am->vRandom.clear();
am->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>());
for (int n = 0; n < am->nNew; n++)
{ {
CAddrInfo &info = am->mapInfo[n]; LOCK(cs);
READWRITE(info);
am->mapAddr[info] = n; 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(); 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
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