mirror of
https://github.com/Xahau/xahaud.git
synced 2025-12-06 17:27:52 +00:00
318 lines
10 KiB
C++
318 lines
10 KiB
C++
#ifndef __SHAMAP__
|
|
#define __SHAMAP__
|
|
|
|
#include <list>
|
|
#include <map>
|
|
#include <stack>
|
|
|
|
#include <boost/shared_ptr.hpp>
|
|
#include <boost/enable_shared_from_this.hpp>
|
|
#include <boost/unordered/unordered_map.hpp>
|
|
|
|
#include "types.h"
|
|
#include "uint256.h"
|
|
#include "ScopedLock.h"
|
|
#include "Serializer.h"
|
|
#include "HashedObject.h"
|
|
|
|
class SHAMap;
|
|
|
|
// A tree-like map of SHA256 hashes
|
|
// The trees are designed for rapid synchronization and compression of differences
|
|
|
|
|
|
class SHAMapNode
|
|
{ // Identifies a node in a SHA256 hash
|
|
public:
|
|
typedef boost::shared_ptr<SHAMapNode> pointer;
|
|
|
|
private:
|
|
static uint256 smMasks[64]; // AND with hash to get node id
|
|
|
|
uint256 mNodeID;
|
|
int mDepth;
|
|
|
|
public:
|
|
|
|
static const int rootDepth=0;
|
|
|
|
SHAMapNode() : mDepth(0) { ; }
|
|
SHAMapNode(int depth, const uint256& hash);
|
|
int getDepth() const { return mDepth; }
|
|
const uint256& getNodeID() const { return mNodeID; }
|
|
bool isValid() const { return (mDepth>=0) && (mDepth<64); }
|
|
|
|
virtual bool isPopulated() const { return false; }
|
|
|
|
SHAMapNode getParentNodeID() const
|
|
{
|
|
assert(mDepth);
|
|
return SHAMapNode(mDepth-1, mNodeID);
|
|
}
|
|
SHAMapNode getChildNodeID(int m) const;
|
|
int selectBranch(const uint256& hash) const;
|
|
|
|
bool operator<(const SHAMapNode&) const;
|
|
bool operator>(const SHAMapNode&) const;
|
|
bool operator==(const SHAMapNode&) const;
|
|
bool operator==(const uint256&) const;
|
|
bool operator!=(const SHAMapNode&) const;
|
|
bool operator!=(const uint256&) const;
|
|
bool operator<=(const SHAMapNode&) const;
|
|
bool operator>=(const SHAMapNode&) const;
|
|
bool isRoot() const { return mDepth==0; }
|
|
|
|
virtual std::string getString() const;
|
|
void dump() const;
|
|
|
|
static void ClassInit();
|
|
static uint256 getNodeID(int depth, const uint256& hash);
|
|
|
|
// Convert to/from wire format (256-bit nodeID, 1-byte depth)
|
|
void addIDRaw(Serializer &s) const;
|
|
static int getRawIDLength(void) { return 33; }
|
|
SHAMapNode(const void *ptr, int len);
|
|
};
|
|
|
|
class hash_SMN
|
|
{ // These must be randomized for release
|
|
public:
|
|
std::size_t operator() (const SHAMapNode& mn) const
|
|
{ return mn.getDepth() ^ static_cast<std::size_t>(mn.getNodeID().GetAt(0)); }
|
|
std::size_t operator() (const uint256& u) const
|
|
{ return static_cast<std::size_t>(u.GetAt(0)); }
|
|
};
|
|
|
|
class SHAMapItem
|
|
{ // an item stored in a SHAMap
|
|
public:
|
|
typedef boost::shared_ptr<SHAMapItem> pointer;
|
|
|
|
private:
|
|
uint256 mTag;
|
|
std::vector<unsigned char> mData;
|
|
|
|
public:
|
|
|
|
// for transactions
|
|
SHAMapItem(const uint256& tag, const std::vector<unsigned char>& data);
|
|
SHAMapItem(const std::vector<unsigned char>& data); // tag by hash
|
|
|
|
// for account balances
|
|
SHAMapItem(const uint160& tag, const std::vector<unsigned char>& data);
|
|
|
|
const uint256& getTag() const { return mTag; }
|
|
std::vector<unsigned char> getData() const { return mData; }
|
|
const std::vector<unsigned char>& peekData() const { return mData; }
|
|
void addRaw(Serializer &s) { s.addRaw(mData); }
|
|
void addRaw(std::vector<unsigned char>& s) { s.insert(s.end(), mData.begin(), mData.end()); }
|
|
|
|
void updateData(const std::vector<unsigned char>& data) { mData=data; }
|
|
|
|
bool operator<(const SHAMapItem& i) const { return mTag<i.mTag; }
|
|
bool operator>(const SHAMapItem& i) const { return mTag>i.mTag; }
|
|
bool operator==(const SHAMapItem& i) const { return mTag==i.mTag; }
|
|
bool operator!=(const SHAMapItem& i) const { return mTag!=i.mTag; }
|
|
bool operator<=(const SHAMapItem& i) const { return mTag<=i.mTag; }
|
|
bool operator>=(const SHAMapItem& i) const { return mTag>=i.mTag; }
|
|
bool operator<(const uint256& i) const { return mTag<i; }
|
|
bool operator>(const uint256& i) const { return mTag>i; }
|
|
bool operator==(const uint256& i) const { return mTag==i; }
|
|
bool operator!=(const uint256& i) const { return mTag!=i; }
|
|
bool operator<=(const uint256& i) const { return mTag<=i; }
|
|
bool operator>=(const uint256& i) const { return mTag>=i; }
|
|
virtual void dump();
|
|
};
|
|
|
|
class SHAMapTreeNode : public SHAMapNode
|
|
{
|
|
friend class SHAMap;
|
|
|
|
public:
|
|
typedef boost::shared_ptr<SHAMapTreeNode> pointer;
|
|
|
|
enum TNType
|
|
{
|
|
ERROR =0,
|
|
INNER =1,
|
|
TRANSACTION =2,
|
|
ACCOUNT_STATE =3
|
|
};
|
|
|
|
private:
|
|
uint256 mHash;
|
|
uint256 mHashes[16];
|
|
SHAMapItem::pointer mItem;
|
|
uint32 mSeq;
|
|
TNType mType;
|
|
bool mFullBelow;
|
|
|
|
bool updateHash();
|
|
|
|
SHAMapTreeNode(const SHAMapTreeNode&); // no implementation
|
|
SHAMapTreeNode& operator=(const SHAMapTreeNode&); // no implementation
|
|
|
|
public:
|
|
SHAMapTreeNode(const SHAMapNode& nodeID, uint32 seq); // empty node
|
|
SHAMapTreeNode(const SHAMapTreeNode& node, uint32 seq); // copy node from older tree
|
|
SHAMapTreeNode(const SHAMapNode& nodeID, SHAMapItem::pointer item, TNType type, uint32 seq);
|
|
|
|
// raw node functions
|
|
SHAMapTreeNode(const SHAMapNode& id, const std::vector<unsigned char>& contents, uint32 seq); // raw node
|
|
void addRaw(Serializer &);
|
|
|
|
virtual bool isPopulated() const { return true; }
|
|
|
|
// node functions
|
|
uint32 getSeq() const { return mSeq; }
|
|
void setSeq(uint32 s) { mSeq=s; }
|
|
const uint256& getNodeHash() const { return mHash; }
|
|
TNType getType() const { return mType; }
|
|
|
|
// type functions
|
|
bool isLeaf() const { return (mType==TRANSACTION) || (mType==ACCOUNT_STATE); }
|
|
bool isInner() const { return mType==INNER; }
|
|
bool isValid() const { return mType!=ERROR; }
|
|
bool isTransaction() const { return mType!=TRANSACTION; }
|
|
bool isAccountState() const { return mType!=ACCOUNT_STATE; }
|
|
|
|
// inner node functions
|
|
bool isInnerNode() const { return !mItem; }
|
|
bool setChildHash(int m, const uint256& hash);
|
|
const uint256& getChildHash(int m) const;
|
|
bool isEmptyBranch(int m) const { return !mHashes[m]; }
|
|
int getBranchCount() const;
|
|
void makeInner();
|
|
|
|
// item node function
|
|
bool hasItem() const { return !!mItem; }
|
|
SHAMapItem::pointer peekItem() { return mItem; }
|
|
SHAMapItem::pointer getItem() const;
|
|
bool setItem(SHAMapItem::pointer& i, TNType type);
|
|
const uint256& getTag() const { return mItem->getTag(); }
|
|
const std::vector<unsigned char>& peekData() { return mItem->peekData(); }
|
|
std::vector<unsigned char> getData() const { return mItem->getData(); }
|
|
|
|
// sync functions
|
|
bool isFullBelow(void) const { return mFullBelow; }
|
|
void setFullBelow(void) { mFullBelow=true; }
|
|
|
|
virtual void dump();
|
|
virtual std::string getString() const;
|
|
};
|
|
|
|
enum SHAMapException
|
|
{
|
|
MissingNode=1,
|
|
InvalidNode=2,
|
|
InvalidMap=3,
|
|
};
|
|
|
|
class SHAMap
|
|
{
|
|
public:
|
|
typedef boost::shared_ptr<SHAMap> pointer;
|
|
typedef std::map<uint256, std::pair<SHAMapItem::pointer, SHAMapItem::pointer> > SHAMapDiff;
|
|
|
|
private:
|
|
uint32 mSeq;
|
|
mutable boost::recursive_mutex mLock;
|
|
boost::unordered_map<SHAMapNode, SHAMapTreeNode::pointer, hash_SMN> mTNByID;
|
|
|
|
boost::shared_ptr<std::map<SHAMapNode, SHAMapTreeNode::pointer> > mDirtyNodes;
|
|
|
|
SHAMapTreeNode::pointer root;
|
|
|
|
bool mImmutable, mSynching;
|
|
|
|
protected:
|
|
|
|
void dirtyUp(std::stack<SHAMapTreeNode::pointer>& stack, const uint256& target, uint256 prevHash);
|
|
std::stack<SHAMapTreeNode::pointer> getStack(const uint256& id, bool include_nonmatching_leaf);
|
|
SHAMapTreeNode::pointer walkTo(const uint256& id, bool modify);
|
|
SHAMapTreeNode::pointer checkCacheNode(const SHAMapNode&);
|
|
void returnNode(SHAMapTreeNode::pointer&, bool modify);
|
|
|
|
SHAMapTreeNode::pointer getNode(const SHAMapNode& id);
|
|
SHAMapTreeNode::pointer getNode(const SHAMapNode& id, const uint256& hash, bool modify);
|
|
|
|
SHAMapItem::pointer firstBelow(SHAMapTreeNode::pointer);
|
|
SHAMapItem::pointer lastBelow(SHAMapTreeNode::pointer);
|
|
SHAMapItem::pointer onlyBelow(SHAMapTreeNode::pointer);
|
|
void eraseChildren(SHAMapTreeNode::pointer);
|
|
|
|
bool walkBranch(SHAMapTreeNode::pointer node, SHAMapItem::pointer otherMapItem, bool isFirstMap,
|
|
SHAMapDiff& differences, int& maxCount);
|
|
|
|
public:
|
|
|
|
// build new map
|
|
SHAMap(uint32 seq=0);
|
|
|
|
// hold the map stable across operations
|
|
ScopedLock Lock() const { return ScopedLock(mLock); }
|
|
|
|
bool hasNode(const SHAMapNode& id);
|
|
|
|
// normal hash access functions
|
|
bool hasItem(const uint256& id);
|
|
bool delItem(const uint256& id);
|
|
bool addItem(const SHAMapItem& i, bool isTransaction);
|
|
bool updateItem(const SHAMapItem& i, bool isTransaction);
|
|
SHAMapItem getItem(const uint256& id);
|
|
uint256 getHash() const { return root->getNodeHash(); }
|
|
uint256 getHash() { return root->getNodeHash(); }
|
|
|
|
// save a copy if you have a temporary anyway
|
|
bool updateGiveItem(SHAMapItem::pointer, bool isTransaction);
|
|
bool addGiveItem(SHAMapItem::pointer, bool isTransaction);
|
|
|
|
// save a copy if you only need a temporary
|
|
SHAMapItem::pointer peekItem(const uint256& id);
|
|
|
|
// traverse functions
|
|
SHAMapItem::pointer peekFirstItem();
|
|
SHAMapItem::pointer peekLastItem();
|
|
SHAMapItem::pointer peekNextItem(const uint256&);
|
|
SHAMapItem::pointer peekPrevItem(const uint256&);
|
|
|
|
SHAMapItem::pointer peekPrevItem(const uint160& u) { return peekPrevItem(u.to256()); }
|
|
SHAMapItem::pointer peekNextItem(const uint160& u) { return peekNextItem(u.to256()); }
|
|
|
|
// comparison/sync functions
|
|
void getMissingNodes(std::vector<SHAMapNode>& nodeIDs, std::vector<uint256>& hashes, int max);
|
|
bool getNodeFat(const SHAMapNode& node, std::vector<SHAMapNode>& nodeIDs,
|
|
std::list<std::vector<unsigned char> >& rawNode);
|
|
bool addRootNode(const uint256& hash, const std::vector<unsigned char>& rootNode);
|
|
bool addRootNode(const std::vector<unsigned char>& rootNode);
|
|
bool addKnownNode(const SHAMapNode& nodeID, const std::vector<unsigned char>& rawNode);
|
|
|
|
// status functions
|
|
void setImmutable(void) { mImmutable=true; }
|
|
void clearImmutable(void) { mImmutable=false; }
|
|
bool isSynching(void) const { return mSynching; }
|
|
void setSynching(void) { mSynching=true; }
|
|
void clearSynching(void) { mSynching=false; }
|
|
|
|
// caution: otherMap must be accessed only by this function
|
|
// return value: true=successfully completed, false=too different
|
|
bool compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxCount);
|
|
|
|
int flushDirty(int maxNodes, HashedObjectType t, uint32 seq);
|
|
|
|
void setSeq(uint32 seq) { mSeq=seq; }
|
|
uint32 getSeq() { return mSeq; }
|
|
|
|
// overloads for backed maps
|
|
bool fetchNode(const uint256& hash, std::vector<unsigned char>& rawNode);
|
|
|
|
bool operator==(const SHAMap& s) { return getHash()==s.getHash(); }
|
|
|
|
static bool TestSHAMap();
|
|
static bool syncTest();
|
|
bool deepCompare(SHAMap& other);
|
|
virtual void dump(bool withHashes=false);
|
|
};
|
|
|
|
#endif
|