ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-12-06 17:27:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix threading.

Browse Source
This commit is contained in:
JoelKatz
2012-08-27 03:04:33 -07:00
parent bb7f692a76
commit 9148127083
4 changed files with 36 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/LedgerEntrySet.cpp
View File

@@ -259,31 +259,38 @@ SLE::pointer LedgerEntrySet::getForMod(const uint256& node, Ledger::pointer& led
}
bool LedgerEntrySet::threadNode(SLE::pointer& node, const NewcoinAddress& threadTo, Ledger::pointer& ledger,
bool LedgerEntrySet::threadTx(TransactionMetaNode& metaNode, const NewcoinAddress& threadTo, Ledger::pointer& ledger,
boost::unordered_map<uint256, SLE::pointer>& newMods)
{
SLE::pointer sle = getForMod(Ledger::getAccountRootIndex(threadTo.getAccountID()), ledger, newMods);
if ((!sle) || (sle->getIndex() == node->getIndex())) // do not self-thread
if (!sle)
return false;
return threadNode(node, sle, ledger, newMods);
return threadTx(metaNode, sle, ledger, newMods);
}
bool LedgerEntrySet::threadNode(SLE::pointer& node, SLE::pointer& threadTo, Ledger::pointer& ledger,
bool LedgerEntrySet::threadTx(TransactionMetaNode& metaNode, SLE::pointer& threadTo, Ledger::pointer& ledger,
boost::unordered_map<uint256, SLE::pointer>& newMods)
{
// WRITEME
{ // node = the node that was modified/deleted/created
// threadTo = the node that needs to know
uint256 prevTxID;
uint32 prevLgrID;
if (!threadTo->thread(mSet.getTxID(), mSet.getLgrSeq(), prevTxID, prevLgrID))
return false;
if (metaNode.thread(prevTxID, prevLgrID))
return true;
assert(false);
return false;
}
bool LedgerEntrySet::threadOwners(SLE::pointer& node, Ledger::pointer& ledger,
bool LedgerEntrySet::threadOwners(TransactionMetaNode& metaNode, SLE::pointer& node, Ledger::pointer& ledger,
boost::unordered_map<uint256, SLE::pointer>& newMods)
{ // thread new or modified node to owner or owners
if (node->hasOneOwner()) // thread to owner's account
return threadNode(node, node->getOwner(), ledger, newMods);
return threadTx(metaNode, node->getOwner(), ledger, newMods);
else if (node->hasTwoOwners()) // thread to owner's accounts
return
threadNode(node, node->getFirstOwner(), ledger, newMods) ||
threadNode(node, node->getSecondOwner(), ledger, newMods);
threadTx(metaNode, node->getFirstOwner(), ledger, newMods) ||
threadTx(metaNode, node->getSecondOwner(), ledger, newMods);
else
return false;
}
@@ -318,10 +325,11 @@ void LedgerEntrySet::calcRawMeta(Serializer& s, Ledger::pointer& origLedger)
{
SLE::pointer origNode = origLedger->getSLE(it->first);
SLE::pointer curNode = it->second.mEntry;
TransactionMetaNode &metaNode = mSet.getAffectedNode(it->first, nType);
if (nType == TMNDeletedNode)
{
threadOwners(origNode, origLedger, newMod);
threadOwners(metaNode, origNode, origLedger, newMod);
if (origNode->getType() == ltOFFER)
{ // check for non-zero balances
@@ -332,10 +340,10 @@ void LedgerEntrySet::calcRawMeta(Serializer& s, Ledger::pointer& origLedger)
if ((nType == TMNCreatedNode) || (nType == TMNModifiedNode))
{
if (nType == TMNCreatedNode) // if created, thread to owner(s)
threadOwners(curNode, origLedger, newMod);
threadOwners(metaNode, curNode, origLedger, newMod);
if (curNode->isThreadedType()) // always thread to self
threadNode(curNode, curNode, origLedger, newMod);
threadTx(metaNode, curNode, origLedger, newMod);
if (nType == TMNModifiedNode)
{

6
src/LedgerEntrySet.h
View File

@@ -41,13 +41,13 @@ protected:
SLE::pointer getForMod(const uint256& node, Ledger::pointer& ledger,
boost::unordered_map<uint256, SLE::pointer>& newMods);
bool threadNode(SLE::pointer& node, const NewcoinAddress& threadTo, Ledger::pointer& ledger,
bool threadTx(TransactionMetaNode& metaNode, const NewcoinAddress& threadTo, Ledger::pointer& ledger,
boost::unordered_map<uint256, SLE::pointer>& newMods);
bool threadNode(SLE::pointer& node, SLE::pointer& threadTo, Ledger::pointer& ledger,
bool threadTx(TransactionMetaNode& metaNode, SLE::pointer& threadTo, Ledger::pointer& ledger,
boost::unordered_map<uint256, SLE::pointer>& newMods);
bool threadOwners(SLE::pointer& node, Ledger::pointer& ledger,
bool threadOwners(TransactionMetaNode& metaNode, SLE::pointer& node, Ledger::pointer& ledger,
boost::unordered_map<uint256, SLE::pointer>& newMods);
public:

33
src/TransactionMeta.cpp
View File

@@ -262,6 +262,14 @@ bool TransactionMetaSet::isNodeAffected(const uint256& node) const
return mNodes.find(node) != mNodes.end();
}
TransactionMetaNode& TransactionMetaSet::getAffectedNode(const uint256& node, int type)
{
std::map<uint256, TransactionMetaNode>::iterator it = mNodes.find(node);
if (it != mNodes.end())
return it->second;
return mNodes.insert(std::make_pair(node, TransactionMetaNode(node, type))).first->second;
}
const TransactionMetaNode& TransactionMetaSet::peekAffectedNode(const uint256& node) const
{
std::map<uint256, TransactionMetaNode>::const_iterator it = mNodes.find(node);
@@ -283,28 +291,3 @@ void TransactionMetaSet::swap(TransactionMetaSet& s)
mNodes.swap(s.mNodes);
}
TransactionMetaNode& TransactionMetaSet::modifyNode(const uint256& node)
{
std::map<uint256, TransactionMetaNode>::iterator it = mNodes.find(node);
if (it != mNodes.end())
return it->second;
return mNodes.insert(std::make_pair(node, TransactionMetaNode(node))).first->second;
}
#if 0
void TransactionMetaSet::threadNode(const uint256& node, const uint256& prevTx, uint32 prevLgr)
{
modifyNode(node).thread(prevTx, prevLgr);
}
void TransactionMetaSet::deleteUnfunded(const uint256& nodeID,
const STAmount& firstBalance, const STAmount &secondBalance)
{
TransactionMetaNode& node = modifyNode(nodeID);
TMNEUnfunded* entry = dynamic_cast<TMNEUnfunded*>(node.findEntry(TransactionMetaNodeEntry::TMNDeleteUnfunded));
if (entry)
entry->setBalances(firstBalance, secondBalance);
else
node.addNode(new TMNEUnfunded(firstBalance, secondBalance));
}
#endif

7
src/TransactionMeta.h
View File

@@ -133,7 +133,7 @@ protected:
boost::ptr_vector<TransactionMetaNodeEntry> mEntries;
public:
TransactionMetaNode(const uint256 &node) : mNode(node) { ; }
TransactionMetaNode(const uint256 &node, int type) : mType(type), mNode(node) { ; }
const uint256& getNode() const { return mNode; }
const boost::ptr_vector<TransactionMetaNodeEntry>& peekEntries() const { return mEntries; }
@@ -163,8 +163,6 @@ protected:
uint32 mLedger;
std::map<uint256, TransactionMetaNode> mNodes;
TransactionMetaNode& modifyNode(const uint256&);
public:
TransactionMetaSet() : mLedger(0) { ; }
TransactionMetaSet(const uint256& txID, uint32 ledger) : mTransactionID(txID), mLedger(ledger) { ; }
@@ -174,6 +172,9 @@ public:
void clear() { mNodes.clear(); }
void swap(TransactionMetaSet&);
const uint256& getTxID() { return mTransactionID; }
uint32 getLgrSeq() { return mLedger; }
bool isNodeAffected(const uint256&) const;
TransactionMetaNode& getAffectedNode(const uint256&, int type);
const TransactionMetaNode& peekAffectedNode(const uint256&) const;