Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

feat: add nodeKey integer field #593

Merged
merged 2 commits into from
Oct 19, 2022
+144 −66
Merged

feat: add nodeKey integer field #593

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4cb3552
add nodeKey integer field
cool-develope Oct 18, 2022
a33d8d1
fix test failures
cool-develope Oct 18, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 8 additions & 0 deletions immutable_tree.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,7 @@ type ImmutableTree struct {
root *Node
ndb *nodeDB
version int64
nonce int64
skipFastStorageUpgrade bool
}

Expand Down Expand Up @@ -131,6 +132,12 @@ func (t *ImmutableTree) Version() int64 {
return t.version
}

// IncreaseNonce increases the nonce by 1 and returns.
func (t *ImmutableTree) IncreaseNonce() int64 {
t.nonce++
return t.nonce
}

// Height returns the height of the tree.
func (t *ImmutableTree) Height() int8 {
if t.root == nil {
Expand Down Expand Up @@ -316,6 +323,7 @@ func (t *ImmutableTree) clone() *ImmutableTree {
root: t.root,
ndb: t.ndb,
version: t.version,
nonce: t.nonce,
}
}

Expand Down
3 changes: 3 additions & 0 deletions import.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -92,6 +92,7 @@ func (i *Importer) Add(exportNode *ExportNode) error {
// We don't modify the stack until we've verified the built node, to avoid leaving the
// importer in an inconsistent state when we return an error.
stackSize := len(i.stack)
node.nodeKey = i.tree.IncreaseNonce()
switch {
case stackSize >= 2 && i.stack[stackSize-1].subtreeHeight < node.subtreeHeight && i.stack[stackSize-2].subtreeHeight < node.subtreeHeight:
node.leftNode = i.stack[stackSize-2]
Expand All @@ -108,9 +109,11 @@ func (i *Importer) Add(exportNode *ExportNode) error {
}
if node.leftNode != nil {
node.size += node.leftNode.size
node.leftNodeKey = node.leftNode.nodeKey
}
if node.rightNode != nil {
node.size += node.rightNode.size
node.rightNodeKey = node.rightNode.nodeKey
}

_, err := node._hash()
Expand Down
101 changes: 58 additions & 43 deletions mutable_tree.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -230,7 +230,7 @@ func (tree *MutableTree) set(key []byte, value []byte) (orphans []*Node, updated
if !tree.skipFastStorageUpgrade {
tree.addUnsavedAddition(key, fastnode.NewNode(key, value, tree.version+1))
}
tree.ImmutableTree.root = NewNode(key, value, tree.version+1)
tree.ImmutableTree.root = NewNode(key, value, tree.version+1, tree.IncreaseNonce())
return nil, updated, nil
}

Expand All @@ -255,26 +255,32 @@ func (tree *MutableTree) recursiveSet(node *Node, key []byte, value []byte, orph
key: node.key,
subtreeHeight: 1,
size: 2,
leftNode: NewNode(key, value, version),
nodeKey: tree.IncreaseNonce(),
rightNode: node,
version: version,
leftNode: NewNode(key, value, version, tree.IncreaseNonce()),
}, false, nil
case 1:
return &Node{
key: key,
subtreeHeight: 1,
size: 2,
leftNode: node,
rightNode: NewNode(key, value, version),
nodeKey: tree.IncreaseNonce(),
version: version,
rightNode: NewNode(key, value, version, tree.IncreaseNonce()),
}, false, nil
default:
*orphans = append(*orphans, node)
return NewNode(key, value, version), true, nil
return NewNode(key, value, version, tree.IncreaseNonce()), true, nil
}
} else {
*orphans = append(*orphans, node)
if node.persisted {
node.nodeKey = tree.IncreaseNonce()
}
node, err = node.clone(version)

if err != nil {
return nil, false, err
}
Expand All @@ -289,6 +295,7 @@ func (tree *MutableTree) recursiveSet(node *Node, key []byte, value []byte, orph
return nil, updated, err
}
node.leftHash = nil // leftHash is yet unknown
node.leftNodeKey = 0
} else {
rightNode, err := node.getRightNode(tree.ImmutableTree)
if err != nil {
Expand All @@ -299,6 +306,7 @@ func (tree *MutableTree) recursiveSet(node *Node, key []byte, value []byte, orph
return nil, updated, err
}
node.rightHash = nil // rightHash is yet unknown
node.rightNodeKey = 0
}

if updated {
Expand All @@ -308,7 +316,6 @@ func (tree *MutableTree) recursiveSet(node *Node, key []byte, value []byte, orph
if err != nil {
return nil, false, err
}

newNode, err := tree.balance(node, orphans)
if err != nil {
return nil, false, err
Expand Down Expand Up @@ -339,7 +346,7 @@ func (tree *MutableTree) remove(key []byte) (value []byte, orphaned []*Node, rem
return nil, nil, false, nil
}
orphaned = tree.prepareOrphansSlice()
newRootHash, newRoot, _, value, err := tree.recursiveRemove(tree.root, key, &orphaned)
newRootHash, _, newRoot, _, value, err := tree.recursiveRemove(tree.root, key, &orphaned)
if err != nil {
return nil, nil, false, err
}
Expand Down Expand Up @@ -369,90 +376,96 @@ func (tree *MutableTree) remove(key []byte) (value []byte, orphaned []*Node, rem
// - new leftmost leaf key for tree after successfully removing 'key' if changed.
// - the removed value
// - the orphaned nodes.
func (tree *MutableTree) recursiveRemove(node *Node, key []byte, orphans *[]*Node) (newHash []byte, newSelf *Node, newKey []byte, newValue []byte, err error) {
func (tree *MutableTree) recursiveRemove(node *Node, key []byte, orphans *[]*Node) (newHash []byte, newNodeKey int64, newSelf *Node, newKey []byte, newValue []byte, err error) {
version := tree.version + 1

if node.isLeaf() {
if bytes.Equal(key, node.key) {
*orphans = append(*orphans, node)
return nil, nil, nil, node.value, nil
return nil, 0, nil, nil, node.value, nil
}
return node.hash, node, nil, nil, nil
return node.hash, node.nodeKey, node, nil, nil, nil
}

// node.key < key; we go to the left to find the key:
if bytes.Compare(key, node.key) < 0 {
leftNode, err := node.getLeftNode(tree.ImmutableTree)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}
newLeftHash, newLeftNode, newKey, value, err := tree.recursiveRemove(leftNode, key, orphans)
newLeftHash, newLeftNodeKey, newLeftNode, newKey, value, err := tree.recursiveRemove(leftNode, key, orphans)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}

if len(*orphans) == 0 {
return node.hash, node, nil, value, nil
return node.hash, node.nodeKey, node, nil, value, nil
}
*orphans = append(*orphans, node)
if newLeftHash == nil && newLeftNode == nil { // left node held value, was removed
return node.rightHash, node.rightNode, node.key, value, nil
return node.rightHash, node.rightNodeKey, node.rightNode, node.key, value, nil
}

newNode, err := node.clone(version)
if node.persisted {
node.nodeKey = tree.IncreaseNonce()
}
node, err = node.clone(version)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}

newNode.leftHash, newNode.leftNode = newLeftHash, newLeftNode
err = newNode.calcHeightAndSize(tree.ImmutableTree)
node.leftHash, node.leftNodeKey, node.leftNode = newLeftHash, newLeftNodeKey, newLeftNode
err = node.calcHeightAndSize(tree.ImmutableTree)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}
newNode, err = tree.balance(newNode, orphans)
node, err = tree.balance(node, orphans)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}

return newNode.hash, newNode, newKey, value, nil
return node.hash, node.nodeKey, node, newKey, value, nil
}
// node.key >= key; either found or look to the right:
rightNode, err := node.getRightNode(tree.ImmutableTree)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}
newRightHash, newRightNode, newKey, value, err := tree.recursiveRemove(rightNode, key, orphans)
newRightHash, newRightNodeKey, newRightNode, newKey, value, err := tree.recursiveRemove(rightNode, key, orphans)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}
if len(*orphans) == 0 {
return node.hash, node, nil, value, nil
return node.hash, node.nodeKey, node, nil, value, nil
}
*orphans = append(*orphans, node)
if newRightHash == nil && newRightNode == nil { // right node held value, was removed
return node.leftHash, node.leftNode, nil, value, nil
return node.leftHash, node.nodeKey, node.leftNode, nil, value, nil
}

newNode, err := node.clone(version)
if node.persisted {
node.nodeKey = tree.IncreaseNonce()
}
node, err = node.clone(version)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}

newNode.rightHash, newNode.rightNode = newRightHash, newRightNode
node.rightHash, node.rightNodeKey, node.rightNode = newRightHash, newRightNodeKey, newRightNode
if newKey != nil {
newNode.key = newKey
node.key = newKey
}
err = newNode.calcHeightAndSize(tree.ImmutableTree)
err = node.calcHeightAndSize(tree.ImmutableTree)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}

newNode, err = tree.balance(newNode, orphans)
node, err = tree.balance(node, orphans)
if err != nil {
return nil, nil, nil, nil, err
return nil, 0, nil, nil, nil, err
}

return newNode.hash, newNode, nil, value, nil
return node.hash, node.nodeKey, node, nil, value, nil
}

// Load the latest versioned tree from disk.
Expand Down Expand Up @@ -874,7 +887,7 @@ func (tree *MutableTree) SaveVersion() ([]byte, int64, error) {
}
} else {
logger.Debug("SAVE TREE %v\n", version)
if _, err := tree.ndb.SaveBranch(tree.root); err != nil {
if _, _, err := tree.ndb.SaveBranch(tree.root); err != nil {
return nil, 0, err
}
if err := tree.ndb.SaveOrphans(version, tree.orphans); err != nil {
Expand Down Expand Up @@ -1096,9 +1109,9 @@ func (tree *MutableTree) rotateRight(node *Node) (*Node, *Node, error) {
return nil, nil, err
}

newNoderHash, newNoderCached := newNode.rightHash, newNode.rightNode
newNode.rightHash, newNode.rightNode = node.hash, node
node.leftHash, node.leftNode = newNoderHash, newNoderCached
node.nodeKey, newNode.nodeKey = newNode.nodeKey, node.nodeKey
node.leftHash, node.leftNodeKey, node.leftNode = newNode.rightHash, newNode.rightNodeKey, newNode.rightNode
newNode.rightNode = node

err = node.calcHeightAndSize(tree.ImmutableTree)
if err != nil {
Expand Down Expand Up @@ -1133,9 +1146,9 @@ func (tree *MutableTree) rotateLeft(node *Node) (*Node, *Node, error) {
return nil, nil, err
}

newNodelHash, newNodelCached := newNode.leftHash, newNode.leftNode
newNode.leftHash, newNode.leftNode = node.hash, node
node.rightHash, node.rightNode = newNodelHash, newNodelCached
node.nodeKey, newNode.nodeKey = newNode.nodeKey, node.nodeKey
node.rightHash, node.rightNodeKey, node.rightNode = newNode.leftHash, newNode.leftNodeKey, newNode.leftNode
newNode.leftNode = node

err = node.calcHeightAndSize(tree.ImmutableTree)
if err != nil {
Expand Down Expand Up @@ -1189,6 +1202,7 @@ func (tree *MutableTree) balance(node *Node, orphans *[]*Node) (newSelf *Node, e
return nil, err
}
node.leftHash = nil
node.leftNodeKey = 0
node.leftNode, leftOrphaned, err = tree.rotateLeft(left)
if err != nil {
return nil, err
Expand Down Expand Up @@ -1228,6 +1242,7 @@ func (tree *MutableTree) balance(node *Node, orphans *[]*Node) (newSelf *Node, e
return nil, err
}
node.rightHash = nil
node.rightNodeKey = 0
node.rightNode, rightOrphaned, err = tree.rotateRight(right)
if err != nil {
return nil, err
Expand Down
Loading