certusone
/
tendermint
mirror of https://github.com/certusone/tendermint.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

...

This commit is contained in:
Jae Kwon 2014-10-06 01:46:39 -07:00
parent 839301b03c
commit 335b7a5984
5 changed files with 115 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

209
merkle/iavl_node.go
View File

@ -16,21 +16,17 @@ type IAVLNode struct {
height uint8 height uint8
hash []byte hash []byte
leftHash []byte leftHash []byte
leftNode *IAVLNode
rightHash []byte rightHash []byte
rightNode *IAVLNode
persisted bool persisted bool
// May or may not be persisted nodes, but they'll get cleared
// when this this node is saved.
leftCached *IAVLNode
rightCached *IAVLNode
} }
func NewIAVLNode(key []byte, value []byte) *IAVLNode { func NewIAVLNode(key []byte, value []byte) *IAVLNode {
return &IAVLNode{ return &IAVLNode{
key: key, key: key,
value: value, value: value,
size: 1, size: 1,
persisted: false,
} }
} }
@ -47,12 +43,9 @@ func ReadIAVLNode(r io.Reader, n *int64, err *error) *IAVLNode {
// node value or children. // node value or children.
if node.height == 0 { if node.height == 0 {
// value
node.value = ReadByteSlice(r, n, err) node.value = ReadByteSlice(r, n, err)
} else { } else {
// left
node.leftHash = ReadByteSlice(r, n, err) node.leftHash = ReadByteSlice(r, n, err)
// right
node.rightHash = ReadByteSlice(r, n, err) node.rightHash = ReadByteSlice(r, n, err)
} }
if *err != nil { if *err != nil {
@ -66,15 +59,15 @@ func (self *IAVLNode) Copy() *IAVLNode {
panic("Why are you copying a value node?") panic("Why are you copying a value node?")
} }
return &IAVLNode{ return &IAVLNode{
key: self.key, key: self.key,
size: self.size, size: self.size,
height: self.height, height: self.height,
hash: nil, // Going to be mutated anyways. hash: nil, // Going to be mutated anyways.
leftHash: self.leftHash, leftHash: self.leftHash,
rightHash: self.rightHash, leftNode: self.leftNode,
persisted: self.persisted, rightHash: self.rightHash,
leftCached: self.leftCached, rightNode: self.rightNode,
rightCached: self.rightCached, persisted: self.persisted,
} }
} }
@ -94,9 +87,9 @@ func (self *IAVLNode) has(ndb *IAVLNodeDB, key []byte) (has bool) {
return false return false
} else { } else {
if bytes.Compare(key, self.key) == -1 { if bytes.Compare(key, self.key) == -1 {
return self.getLeft(ndb).has(ndb, key) return self.getLeftNode(ndb).has(ndb, key)
} else { } else {
return self.getRight(ndb).has(ndb, key) return self.getRightNode(ndb).has(ndb, key)
} }
} }
} }
@ -110,9 +103,9 @@ func (self *IAVLNode) get(ndb *IAVLNodeDB, key []byte) (value []byte) {
} }
} else { } else {
if bytes.Compare(key, self.key) == -1 { if bytes.Compare(key, self.key) == -1 {
return self.getLeft(ndb).get(ndb, key) return self.getLeftNode(ndb).get(ndb, key)
} else { } else {
return self.getRight(ndb).get(ndb, key) return self.getRightNode(ndb).get(ndb, key)
} }
} }
} }
@ -123,7 +116,7 @@ func (self *IAVLNode) HashWithCount() ([]byte, uint64) {
} }
hasher := sha256.New() hasher := sha256.New()
_, hashCount, err := self.saveToCountHashes(hasher) _, hashCount, err := self.writeToCountHashes(hasher)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -140,14 +133,14 @@ func (self *IAVLNode) Save(ndb *IAVLNodeDB) []byte {
return self.hash return self.hash
} }
// children // save children
if self.leftCached != nil { if self.leftNode != nil {
self.leftHash = self.leftCached.Save(ndb) self.leftHash = self.leftNode.Save(ndb)
self.leftCached = nil self.leftNode = nil
} }
if self.rightCached != nil { if self.rightNode != nil {
self.rightHash = self.rightCached.Save(ndb) self.rightHash = self.rightNode.Save(ndb)
self.rightCached = nil self.rightNode = nil
} }
// save self // save self
@ -159,30 +152,30 @@ func (self *IAVLNode) set(ndb *IAVLNodeDB, key []byte, value []byte) (_ *IAVLNod
if self.height == 0 { if self.height == 0 {
if bytes.Compare(key, self.key) == -1 { if bytes.Compare(key, self.key) == -1 {
return &IAVLNode{ return &IAVLNode{
key: self.key, key: self.key,
height: 1, height: 1,
size: 2, size: 2,
leftCached: NewIAVLNode(key, value), leftNode: NewIAVLNode(key, value),
rightCached: self, rightNode: self,
}, false }, false
} else if bytes.Equal(self.key, key) { } else if bytes.Equal(self.key, key) {
return NewIAVLNode(key, value), true return NewIAVLNode(key, value), true
} else { } else {
return &IAVLNode{ return &IAVLNode{
key: key, key: key,
height: 1, height: 1,
size: 2, size: 2,
leftCached: self, leftNode: self,
rightCached: NewIAVLNode(key, value), rightNode: NewIAVLNode(key, value),
}, false }, false
} }
} else { } else {
self = self.Copy() self = self.Copy()
if bytes.Compare(key, self.key) == -1 { if bytes.Compare(key, self.key) == -1 {
self.leftCached, updated = self.getLeft(ndb).set(ndb, key, value) self.leftNode, updated = self.getLeftNode(ndb).set(ndb, key, value)
self.leftHash = nil self.leftHash = nil
} else { } else {
self.rightCached, updated = self.getRight(ndb).set(ndb, key, value) self.rightNode, updated = self.getRightNode(ndb).set(ndb, key, value)
self.rightHash = nil self.rightHash = nil
} }
if updated { if updated {
@ -194,10 +187,11 @@ func (self *IAVLNode) set(ndb *IAVLNodeDB, key []byte, value []byte) (_ *IAVLNod
} }
} }
// newHash/newNode: The new hash or node to replace self after remove.
// newKey: new leftmost leaf key for tree after successfully removing 'key' if changed. // newKey: new leftmost leaf key for tree after successfully removing 'key' if changed.
// only one of newSelfHash or newSelf is returned. // value: removed value.
func (self *IAVLNode) remove(ndb *IAVLNodeDB, key []byte) ( func (self *IAVLNode) remove(ndb *IAVLNodeDB, key []byte) (
newSelfHash []byte, newSelf *IAVLNode, newKey []byte, value []byte, err error) { newHash []byte, newNode *IAVLNode, newKey []byte, value []byte, err error) {
if self.height == 0 { if self.height == 0 {
if bytes.Equal(self.key, key) { if bytes.Equal(self.key, key) {
return nil, nil, nil, self.value, nil return nil, nil, nil, self.value, nil
@ -207,26 +201,26 @@ func (self *IAVLNode) remove(ndb *IAVLNodeDB, key []byte) (
} else { } else {
if bytes.Compare(key, self.key) == -1 { if bytes.Compare(key, self.key) == -1 {
var newLeftHash []byte var newLeftHash []byte
var newLeft *IAVLNode var newLeftNode *IAVLNode
newLeftHash, newLeft, newKey, value, err = self.getLeft(ndb).remove(ndb, key) newLeftHash, newLeftNode, newKey, value, err = self.getLeftNode(ndb).remove(ndb, key)
if err != nil { if err != nil {
return nil, self, nil, value, err return nil, self, nil, value, err
} else if newLeftHash == nil && newLeft == nil { // left node held value, was removed } else if newLeftHash == nil && newLeftNode == nil { // left node held value, was removed
return self.rightHash, self.rightCached, self.key, value, nil return self.rightHash, self.rightNode, self.key, value, nil
} }
self = self.Copy() self = self.Copy()
self.leftHash, self.leftCached = newLeftHash, newLeft self.leftHash, self.leftNode = newLeftHash, newLeftNode
} else { } else {
var newRightHash []byte var newRightHash []byte
var newRight *IAVLNode var newRightNode *IAVLNode
newRightHash, newRight, newKey, value, err = self.getRight(ndb).remove(ndb, key) newRightHash, newRightNode, newKey, value, err = self.getRightNode(ndb).remove(ndb, key)
if err != nil { if err != nil {
return nil, self, nil, value, err return nil, self, nil, value, err
} else if newRightHash == nil && newRight == nil { // right node held value, was removed } else if newRightHash == nil && newRightNode == nil { // right node held value, was removed
return self.leftHash, self.leftCached, nil, value, nil return self.leftHash, self.leftNode, nil, value, nil
} }
self = self.Copy() self = self.Copy()
self.rightHash, self.rightCached = newRightHash, newRight self.rightHash, self.rightNode = newRightHash, newRightNode
if newKey != nil { if newKey != nil {
self.key = newKey self.key = newKey
newKey = nil newKey = nil
@ -238,11 +232,11 @@ func (self *IAVLNode) remove(ndb *IAVLNodeDB, key []byte) (
} }
func (self *IAVLNode) WriteTo(w io.Writer) (n int64, err error) { func (self *IAVLNode) WriteTo(w io.Writer) (n int64, err error) {
n, _, err = self.saveToCountHashes(w) n, _, err = self.writeToCountHashes(w)
return return
} }
func (self *IAVLNode) saveToCountHashes(w io.Writer) (n int64, hashCount uint64, err error) { func (self *IAVLNode) writeToCountHashes(w io.Writer) (n int64, hashCount uint64, err error) {
// height & size & key // height & size & key
WriteUInt8(w, self.height, &n, &err) WriteUInt8(w, self.height, &n, &err)
WriteUInt64(w, self.size, &n, &err) WriteUInt64(w, self.size, &n, &err)
@ -251,40 +245,45 @@ func (self *IAVLNode) saveToCountHashes(w io.Writer) (n int64, hashCount uint64,
return return
} }
// value or children
if self.height == 0 { if self.height == 0 {
// value // value
WriteByteSlice(w, self.value, &n, &err) WriteByteSlice(w, self.value, &n, &err)
} else { } else {
// left // left
if self.leftCached != nil { if self.leftNode != nil {
leftHash, leftCount := self.leftCached.HashWithCount() leftHash, leftCount := self.leftNode.HashWithCount()
self.leftHash = leftHash self.leftHash = leftHash
hashCount += leftCount hashCount += leftCount
} }
if self.leftHash == nil {
panic("self.leftHash was nil in save")
}
WriteByteSlice(w, self.leftHash, &n, &err) WriteByteSlice(w, self.leftHash, &n, &err)
// right // right
if self.rightCached != nil { if self.rightNode != nil {
rightHash, rightCount := self.rightCached.HashWithCount() rightHash, rightCount := self.rightNode.HashWithCount()
self.rightHash = rightHash self.rightHash = rightHash
hashCount += rightCount hashCount += rightCount
} }
if self.rightHash == nil {
panic("self.rightHash was nil in save")
}
WriteByteSlice(w, self.rightHash, &n, &err) WriteByteSlice(w, self.rightHash, &n, &err)
} }
return return
} }
func (self *IAVLNode) getLeft(ndb *IAVLNodeDB) *IAVLNode { func (self *IAVLNode) getLeftNode(ndb *IAVLNodeDB) *IAVLNode {
if self.leftCached != nil { if self.leftNode != nil {
return self.leftCached return self.leftNode
} else { } else {
return ndb.Get(self.leftHash) return ndb.Get(self.leftHash)
} }
} }
func (self *IAVLNode) getRight(ndb *IAVLNodeDB) *IAVLNode { func (self *IAVLNode) getRightNode(ndb *IAVLNodeDB) *IAVLNode {
if self.rightCached != nil { if self.rightNode != nil {
return self.rightCached return self.rightNode
} else { } else {
return ndb.Get(self.rightHash) return ndb.Get(self.rightHash)
} }
@ -292,11 +291,11 @@ func (self *IAVLNode) getRight(ndb *IAVLNodeDB) *IAVLNode {
func (self *IAVLNode) rotateRight(ndb *IAVLNodeDB) *IAVLNode { func (self *IAVLNode) rotateRight(ndb *IAVLNodeDB) *IAVLNode {
self = self.Copy() self = self.Copy()
sl := self.getLeft(ndb).Copy() sl := self.getLeftNode(ndb).Copy()
slrHash, slrCached := sl.rightHash, sl.rightCached slrHash, slrCached := sl.rightHash, sl.rightNode
sl.rightHash, sl.rightCached = nil, self sl.rightHash, sl.rightNode = nil, self
self.leftHash, self.leftCached = slrHash, slrCached self.leftHash, self.leftNode = slrHash, slrCached
self.calcHeightAndSize(ndb) self.calcHeightAndSize(ndb)
sl.calcHeightAndSize(ndb) sl.calcHeightAndSize(ndb)
@ -306,11 +305,11 @@ func (self *IAVLNode) rotateRight(ndb *IAVLNodeDB) *IAVLNode {
func (self *IAVLNode) rotateLeft(ndb *IAVLNodeDB) *IAVLNode { func (self *IAVLNode) rotateLeft(ndb *IAVLNodeDB) *IAVLNode {
self = self.Copy() self = self.Copy()
sr := self.getRight(ndb).Copy() sr := self.getRightNode(ndb).Copy()
srlHash, srlCached := sr.leftHash, sr.leftCached srlHash, srlCached := sr.leftHash, sr.leftNode
sr.leftHash, sr.leftCached = nil, self sr.leftHash, sr.leftNode = nil, self
self.rightHash, self.rightCached = srlHash, srlCached self.rightHash, self.rightNode = srlHash, srlCached
self.calcHeightAndSize(ndb) self.calcHeightAndSize(ndb)
sr.calcHeightAndSize(ndb) sr.calcHeightAndSize(ndb)
@ -319,36 +318,36 @@ func (self *IAVLNode) rotateLeft(ndb *IAVLNodeDB) *IAVLNode {
} }
func (self *IAVLNode) calcHeightAndSize(ndb *IAVLNodeDB) { func (self *IAVLNode) calcHeightAndSize(ndb *IAVLNodeDB) {
self.height = maxUint8(self.getLeft(ndb).Height(), self.getRight(ndb).Height()) + 1 self.height = maxUint8(self.getLeftNode(ndb).Height(), self.getRightNode(ndb).Height()) + 1
self.size = self.getLeft(ndb).Size() + self.getRight(ndb).Size() self.size = self.getLeftNode(ndb).Size() + self.getRightNode(ndb).Size()
} }
func (self *IAVLNode) calcBalance(ndb *IAVLNodeDB) int { func (self *IAVLNode) calcBalance(ndb *IAVLNodeDB) int {
return int(self.getLeft(ndb).Height()) - int(self.getRight(ndb).Height()) return int(self.getLeftNode(ndb).Height()) - int(self.getRightNode(ndb).Height())
} }
func (self *IAVLNode) balance(ndb *IAVLNodeDB) (newSelf *IAVLNode) { func (self *IAVLNode) balance(ndb *IAVLNodeDB) (newSelf *IAVLNode) {
balance := self.calcBalance(ndb) balance := self.calcBalance(ndb)
if balance > 1 { if balance > 1 {
if self.getLeft(ndb).calcBalance(ndb) >= 0 { if self.getLeftNode(ndb).calcBalance(ndb) >= 0 {
// Left Left Case // Left Left Case
return self.rotateRight(ndb) return self.rotateRight(ndb)
} else { } else {
// Left Right Case // Left Right Case
self = self.Copy() self = self.Copy()
self.leftHash, self.leftCached = nil, self.getLeft(ndb).rotateLeft(ndb) self.leftHash, self.leftNode = nil, self.getLeftNode(ndb).rotateLeft(ndb)
//self.calcHeightAndSize() //self.calcHeightAndSize()
return self.rotateRight(ndb) return self.rotateRight(ndb)
} }
} }
if balance < -1 { if balance < -1 {
if self.getRight(ndb).calcBalance(ndb) <= 0 { if self.getRightNode(ndb).calcBalance(ndb) <= 0 {
// Right Right Case // Right Right Case
return self.rotateLeft(ndb) return self.rotateLeft(ndb)
} else { } else {
// Right Left Case // Right Left Case
self = self.Copy() self = self.Copy()
self.rightHash, self.rightCached = nil, self.getRight(ndb).rotateRight(ndb) self.rightHash, self.rightNode = nil, self.getRightNode(ndb).rotateRight(ndb)
//self.calcHeightAndSize() //self.calcHeightAndSize()
return self.rotateLeft(ndb) return self.rotateLeft(ndb)
} }
@ -357,12 +356,30 @@ func (self *IAVLNode) balance(ndb *IAVLNodeDB) (newSelf *IAVLNode) {
return self return self
} }
func (self *IAVLNode) traverse(ndb *IAVLNodeDB, cb func(*IAVLNode) bool) bool {
stop := cb(self)
if stop {
return stop
}
if self.height > 0 {
stop = self.getLeftNode(ndb).traverse(ndb, cb)
if stop {
return stop
}
stop = self.getRightNode(ndb).traverse(ndb, cb)
if stop {
return stop
}
}
return false
}
// Only used in testing... // Only used in testing...
func (self *IAVLNode) lmd(ndb *IAVLNodeDB) *IAVLNode { func (self *IAVLNode) lmd(ndb *IAVLNodeDB) *IAVLNode {
if self.height == 0 { if self.height == 0 {
return self return self
} }
return self.getLeft(ndb).lmd(ndb) return self.getLeftNode(ndb).lmd(ndb)
} }
// Only used in testing... // Only used in testing...
@ -370,23 +387,5 @@ func (self *IAVLNode) rmd(ndb *IAVLNodeDB) *IAVLNode {
if self.height == 0 { if self.height == 0 {
return self return self
} }
return self.getRight(ndb).rmd(ndb) return self.getRightNode(ndb).rmd(ndb)
}
func (self *IAVLNode) traverse(ndb *IAVLNodeDB, cb func(*IAVLNode) bool) bool {
stop := cb(self)
if stop {
return stop
}
if self.height > 0 {
stop = self.getLeft(ndb).traverse(ndb, cb)
if stop {
return stop
}
stop = self.getRight(ndb).traverse(ndb, cb)
if stop {
return stop
}
}
return false
} }

8
merkle/iavl_test.go
View File

@ -37,9 +37,9 @@ func TestUnit(t *testing.T) {
} }
n := &IAVLNode{ n := &IAVLNode{
key: right.lmd(nil).key, key: right.lmd(nil).key,
leftCached: left, leftNode: left,
rightCached: right, rightNode: right,
} }
n.calcHeightAndSize(nil) n.calcHeightAndSize(nil)
n.HashWithCount() n.HashWithCount()
@ -52,7 +52,7 @@ func TestUnit(t *testing.T) {
if n.height == 0 { if n.height == 0 {
return fmt.Sprintf("%v", n.key[0]) return fmt.Sprintf("%v", n.key[0])
} else { } else {
return fmt.Sprintf("(%v %v)", P(n.leftCached), P(n.rightCached)) return fmt.Sprintf("(%v %v)", P(n.leftNode), P(n.rightNode))
} }
} }

3
merkle/iavl_tree.go
View File

@ -7,6 +7,8 @@ import (
const defaultCacheCapacity = 1000 // TODO make configurable. const defaultCacheCapacity = 1000 // TODO make configurable.
// XXX Make Codec tree.
/* /*
Immutable AVL Tree (wraps the Node root) Immutable AVL Tree (wraps the Node root)
@ -83,7 +85,6 @@ func (t *IAVLTree) Save() {
if t.root == nil { if t.root == nil {
return return
} }
t.root.HashWithCount()
t.root.Save(t.ndb) t.root.Save(t.ndb)
} }

8
merkle/util.go
View File

@ -239,16 +239,16 @@ func printIAVLNode(node *IAVLNode, indent int) {
indentPrefix += " " indentPrefix += " "
} }
if node.rightCached != nil { if node.rightNode != nil {
printIAVLNode(node.rightCached, indent+1) printIAVLNode(node.rightNode, indent+1)
} else if node.rightHash != nil { } else if node.rightHash != nil {
fmt.Printf("%s %X\n", indentPrefix, node.rightHash) fmt.Printf("%s %X\n", indentPrefix, node.rightHash)
} }
fmt.Printf("%s%v:%v\n", indentPrefix, node.key, node.height) fmt.Printf("%s%v:%v\n", indentPrefix, node.key, node.height)
if node.leftCached != nil { if node.leftNode != nil {
printIAVLNode(node.leftCached, indent+1) printIAVLNode(node.leftNode, indent+1)
} else if node.leftHash != nil { } else if node.leftHash != nil {
fmt.Printf("%s %X\n", indentPrefix, node.leftHash) fmt.Printf("%s %X\n", indentPrefix, node.leftHash)
} }

1
p2p/switch.go
View File

@ -156,6 +156,7 @@ func (s *Switch) IsDialing(addr *NetAddress) bool {
return s.dialing.Has(addr.String()) return s.dialing.Has(addr.String())
} }
// XXX: This is wrong, we can't just ignore failures on TrySend.
func (s *Switch) Broadcast(chId byte, msg Binary) (numSuccess, numFailure int) { func (s *Switch) Broadcast(chId byte, msg Binary) (numSuccess, numFailure int) {
if atomic.LoadUint32(&s.stopped) == 1 { if atomic.LoadUint32(&s.stopped) == 1 {
return return