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

Apply max height splay method #989

Closed
wants to merge 6 commits into from
Closed

Apply max height splay method #989

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
e6eb7fc
Apply max height splay method
m4ushold Sep 1, 2024
7a23cb1
Add Account Deletion and Change Password to CLI Commands (#983)
sigmaith Sep 3, 2024
75f2ec7
Merge branch 'main' of https://github.com/yorkie-team/yorkie
m4ushold Sep 4, 2024
fd8a073
Revert "Apply max height splay method"
m4ushold Sep 16, 2024
64d8e6f
Add splay tree Benchmark test
m4ushold Sep 16, 2024
d07df28
fix splay tree bench test
m4ushold Sep 17, 2024
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: 4 additions & 4 deletions pkg/document/document_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -132,22 +132,22 @@ func TestDocument(t *testing.T) {
root.SetNewArray("k1").AddInteger(1).AddInteger(2).AddInteger(3)
assert.Equal(t, 3, root.GetArray("k1").Len())
assert.Equal(t, `{"k1":[1,2,3]}`, root.Marshal())
assert.Equal(t, "[0,0]0[1,1]1[2,1]2[3,1]3", root.GetArray("k1").ToTestString())
assert.Equal(t, "[0,0,1]0[1,1,2]1[2,1,3]2[3,1,4]3", root.GetArray("k1").ToTestString())

root.GetArray("k1").Delete(1)
assert.Equal(t, `{"k1":[1,3]}`, root.Marshal())
assert.Equal(t, 2, root.GetArray("k1").Len())
assert.Equal(t, "[0,0]0[1,1]1[2,0]2[1,1]3", root.GetArray("k1").ToTestString())
assert.Equal(t, "[0,0,1]0[1,1,2]1[2,0,3]2[1,1,1]3", root.GetArray("k1").ToTestString())

root.GetArray("k1").InsertIntegerAfter(0, 2)
assert.Equal(t, `{"k1":[1,2,3]}`, root.Marshal())
assert.Equal(t, 3, root.GetArray("k1").Len())
assert.Equal(t, "[0,0]0[1,1]1[3,1]2[1,0]2[1,1]3", root.GetArray("k1").ToTestString())
assert.Equal(t, "[0,0,1]0[1,1,2]1[3,1,3]2[1,0,2]2[1,1,1]3", root.GetArray("k1").ToTestString())

root.GetArray("k1").InsertIntegerAfter(2, 4)
assert.Equal(t, `{"k1":[1,2,3,4]}`, root.Marshal())
assert.Equal(t, 4, root.GetArray("k1").Len())
assert.Equal(t, "[0,0]0[1,1]1[2,1]2[2,0]2[3,1]3[4,1]4", root.GetArray("k1").ToTestString())
assert.Equal(t, "[0,0,1]0[1,1,2]1[2,1,3]2[2,0,4]2[3,1,5]3[4,1,6]4", root.GetArray("k1").ToTestString())

for i := 0; i < root.GetArray("k1").Len(); i++ {
assert.Equal(
Expand Down
98 changes: 86 additions & 12 deletions pkg/splay/splay.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,6 +36,7 @@ type Value interface {
type Node[V Value] struct {
value V
weight int
height int

left *Node[V]
right *Node[V]
Expand All @@ -45,7 +46,8 @@ type Node[V Value] struct {
// NewNode creates a new instance of Node.
func NewNode[V Value](value V) *Node[V] {
n := &Node[V]{
value: value,
value: value,
height: 1,
}
n.InitWeight()
return n
Expand All @@ -70,6 +72,20 @@ func (t *Node[V]) rightWeight() int {
return t.right.weight
}

func (t *Node[V]) leftHeight() int {
if t.left == nil {
return 0
}
return t.left.height
}

func (t *Node[V]) rightHeight() int {
if t.right == nil {
return 0
}
return t.right.height
}

// InitWeight sets initial weight of this node.
func (t *Node[V]) InitWeight() {
t.weight = t.value.Len()
Expand All @@ -92,13 +108,15 @@ func (t *Node[V]) hasLinks() bool {
// Tree is weighted binary search tree which is based on Splay tree.
// original paper on Splay Trees: https://www.cs.cmu.edu/~sleator/papers/self-adjusting.pdf
type Tree[V Value] struct {
root *Node[V]
root *Node[V]
nodeCount int
}

// NewTree creates a new instance of Tree.
func NewTree[V Value](root *Node[V]) *Tree[V] {
return &Tree[V]{
root: root,
root: root,
nodeCount: 0,
}
}

Expand All @@ -114,6 +132,7 @@ func (t *Tree[V]) Insert(node *Node[V]) *Node[V] {

// InsertAfter inserts the node after the given previous node.
func (t *Tree[V]) InsertAfter(prev *Node[V], node *Node[V]) *Node[V] {
t.BalancingTreeHeight()
t.Splay(prev)
t.root = node
node.right = prev.right
Expand All @@ -124,10 +143,29 @@ func (t *Tree[V]) InsertAfter(prev *Node[V], node *Node[V]) *Node[V] {
prev.parent = node
prev.right = nil

t.UpdateWeight(prev)
t.UpdateNode(prev)
t.UpdateNode(node)
t.nodeCount++
return node
}

// UpdateNode recalculates the height and weight of this node with the value and children.
func (t *Tree[V]) UpdateNode(node *Node[V]) {
t.UpdateWeight(node)
t.UpdateHeight(node)
}

return node
// MaxHeightSplay finds and splays a deapest node.
func (t *Tree[V]) MaxHeightSplay() {
node := t.root
for node.height > 1 {
if node.left != nil && node.left.height+1 == node.height {
node = node.left
} else {
node = node.right
}
}
t.Splay(node)
}

// Splay moves the given node to the root.
Expand Down Expand Up @@ -166,8 +204,26 @@ func (t *Tree[V]) Splay(node *Node[V]) {
}
}

// BalancingTreeHeight call MaxHeightSplay if n(node count) is greater than 1000 and 50*log n
func (t *Tree[V]) BalancingTreeHeight() {
if t.root != nil && t.nodeCount > 1000 {
var threshold uint64
threshold = 1
log := 1
for threshold < uint64(t.nodeCount) {
threshold *= 2
log++
}

if uint64(t.root.height) > uint64(50*log) {
t.MaxHeightSplay()
}
}
}

// IndexOf Find the index of the given node.
func (t *Tree[V]) IndexOf(node *Node[V]) int {
t.BalancingTreeHeight()
if node == nil || node != t.root && !node.hasLinks() {
return -1
}
Expand All @@ -187,6 +243,7 @@ func (t *Tree[V]) IndexOf(node *Node[V]) int {

// Find returns the Node and offset of the given index.
func (t *Tree[V]) Find(index int) (*Node[V], int, error) {
t.BalancingTreeHeight()
if t.root == nil {
return nil, 0, nil
}
Expand Down Expand Up @@ -228,9 +285,10 @@ func (t *Tree[V]) ToTestString() string {

traverseInOrder(t.root, func(node *Node[V]) {
builder.WriteString(fmt.Sprintf(
"[%d,%d]%s",
"[%d,%d,%d]%s",
node.weight,
node.value.Len(),
node.height,
node.value.String(),
))
})
Expand Down Expand Up @@ -265,15 +323,29 @@ func (t *Tree[V]) UpdateWeight(node *Node[V]) {
}
}

// UpdateHeight recalculates the height of this node with the value and children.
func (t *Tree[V]) UpdateHeight(node *Node[V]) {
node.height = 1

if node.left != nil && node.height < node.leftHeight()+1 {
node.height = node.leftHeight() + 1
}

if node.right != nil && node.height < node.rightHeight()+1 {
node.height = node.rightHeight() + 1
}
}

func (t *Tree[V]) updateTreeWeight(node *Node[V]) {
for node != nil {
t.UpdateWeight(node)
t.UpdateNode(node)
node = node.parent
}
}

// Delete deletes the given node from this Tree.
func (t *Tree[V]) Delete(node *Node[V]) {
t.BalancingTreeHeight()
t.Splay(node)

leftTree := NewTree(node.left)
Expand All @@ -300,8 +372,9 @@ func (t *Tree[V]) Delete(node *Node[V]) {

node.unlink()
if t.root != nil {
t.UpdateWeight(t.root)
t.UpdateNode(t.root)
}
t.nodeCount--
}

// DeleteRange separates the range between given 2 boundaries from this Tree.
Expand All @@ -311,6 +384,7 @@ func (t *Tree[V]) Delete(node *Node[V]) {
// but rightBoundary can be nil means range to delete includes the end of tree.
// Refer to the design document: ./design/range-deletion-in-slay-tree.md
func (t *Tree[V]) DeleteRange(leftBoundary, rightBoundary *Node[V]) {
t.BalancingTreeHeight()
if rightBoundary == nil {
t.Splay(leftBoundary)
t.cutOffRight(leftBoundary)
Expand Down Expand Up @@ -351,8 +425,8 @@ func (t *Tree[V]) rotateLeft(pivot *Node[V]) {
pivot.left = root
pivot.left.parent = pivot

t.UpdateWeight(root)
t.UpdateWeight(pivot)
t.UpdateNode(root)
t.UpdateNode(pivot)
}

func (t *Tree[V]) rotateRight(pivot *Node[V]) {
Expand All @@ -376,8 +450,8 @@ func (t *Tree[V]) rotateRight(pivot *Node[V]) {
pivot.right = root
pivot.right.parent = pivot

t.UpdateWeight(root)
t.UpdateWeight(pivot)
t.UpdateNode(root)
t.UpdateNode(pivot)
}

func (t *Tree[V]) rightmost() *Node[V] {
Expand Down
26 changes: 13 additions & 13 deletions pkg/splay/splay_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -56,16 +56,16 @@ func TestSplayTree(t *testing.T) {
assert.Equal(t, 0, idx)

nodeA := tree.Insert(newSplayNode("A2"))
assert.Equal(t, "[2,2]A2", tree.ToTestString())
assert.Equal(t, "[2,2,1]A2", tree.ToTestString())
nodeB := tree.Insert(newSplayNode("B23"))
assert.Equal(t, "[2,2]A2[5,3]B23", tree.ToTestString())
assert.Equal(t, "[2,2,1]A2[5,3,2]B23", tree.ToTestString())
nodeC := tree.Insert(newSplayNode("C234"))
assert.Equal(t, "[2,2]A2[5,3]B23[9,4]C234", tree.ToTestString())
assert.Equal(t, "[2,2,1]A2[5,3,2]B23[9,4,3]C234", tree.ToTestString())
nodeD := tree.Insert(newSplayNode("D2345"))
assert.Equal(t, "[2,2]A2[5,3]B23[9,4]C234[14,5]D2345", tree.ToTestString())
assert.Equal(t, "[2,2,1]A2[5,3,2]B23[9,4,3]C234[14,5,4]D2345", tree.ToTestString())

tree.Splay(nodeB)
assert.Equal(t, "[2,2]A2[14,3]B23[9,4]C234[5,5]D2345", tree.ToTestString())
assert.Equal(t, "[2,2,1]A2[14,3,3]B23[9,4,2]C234[5,5,1]D2345", tree.ToTestString())

assert.Equal(t, 0, tree.IndexOf(nodeA))
assert.Equal(t, 2, tree.IndexOf(nodeB))
Expand All @@ -92,20 +92,20 @@ func TestSplayTree(t *testing.T) {
tree := splay.NewTree[*stringValue](nil)

nodeH := tree.Insert(newSplayNode("H"))
assert.Equal(t, "[1,1]H", tree.ToTestString())
assert.Equal(t, "[1,1,1]H", tree.ToTestString())
assert.Equal(t, 1, tree.Len())
nodeE := tree.Insert(newSplayNode("E"))
assert.Equal(t, "[1,1]H[2,1]E", tree.ToTestString())
assert.Equal(t, "[1,1,1]H[2,1,2]E", tree.ToTestString())
assert.Equal(t, 2, tree.Len())
nodeL := tree.Insert(newSplayNode("LL"))
assert.Equal(t, "[1,1]H[2,1]E[4,2]LL", tree.ToTestString())
assert.Equal(t, "[1,1,1]H[2,1,2]E[4,2,3]LL", tree.ToTestString())
assert.Equal(t, 4, tree.Len())
nodeO := tree.Insert(newSplayNode("O"))
assert.Equal(t, "[1,1]H[2,1]E[4,2]LL[5,1]O", tree.ToTestString())
assert.Equal(t, "[1,1,1]H[2,1,2]E[4,2,3]LL[5,1,4]O", tree.ToTestString())
assert.Equal(t, 5, tree.Len())

tree.Delete(nodeE)
assert.Equal(t, "[4,1]H[3,2]LL[1,1]O", tree.ToTestString())
assert.Equal(t, "[4,1,3]H[3,2,2]LL[1,1,1]O", tree.ToTestString())
assert.Equal(t, 4, tree.Len())

assert.Equal(t, tree.IndexOf(nodeH), 0)
Expand All @@ -121,7 +121,7 @@ func TestSplayTree(t *testing.T) {
tree.DeleteRange(nodes[6], nil)
assert.Equal(
t,
"[1,1]A[3,2]BB[6,3]CCC[10,4]DDDD[15,5]EEEEE[19,4]FFFF[22,3]GGG[0,0]HH[0,0]I",
"[1,1,1]A[3,2,2]BB[6,3,3]CCC[10,4,4]DDDD[15,5,5]EEEEE[19,4,6]FFFF[22,3,7]GGG[0,0,2]HH[0,0,1]I",
tree.ToTestString(),
)

Expand All @@ -131,7 +131,7 @@ func TestSplayTree(t *testing.T) {
tree.DeleteRange(nodes[2], nodes[7])
assert.Equal(
t,
"[1,1]A[3,2]BB[6,3]CCC[0,0]DDDD[0,0]EEEEE[0,0]FFFF[0,0]GGG[9,2]HH[1,1]I",
"[1,1,1]A[3,2,2]BB[6,3,4]CCC[0,0,2]DDDD[0,0,1]EEEEE[0,0,3]FFFF[0,0,1]GGG[9,2,5]HH[1,1,1]I",
tree.ToTestString(),
)

Expand All @@ -143,7 +143,7 @@ func TestSplayTree(t *testing.T) {
tree.DeleteRange(nodes[2], nodes[8])
assert.Equal(
t,
"[1,1]A[3,2]BB[6,3]CCC[0,0]DDDD[0,0]EEEEE[0,0]FFFF[0,0]GGG[0,0]HH[7,1]I",
"[1,1,1]A[3,2,2]BB[6,3,4]CCC[0,0,2]DDDD[0,0,1]EEEEE[0,0,3]FFFF[0,0,1]GGG[0,0,2]HH[7,1,5]I",
tree.ToTestString(),
)
})
Expand Down
8 changes: 4 additions & 4 deletions test/bench/document_bench_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -142,22 +142,22 @@ func BenchmarkDocument(b *testing.B) {
root.SetNewArray("k1").AddInteger(1).AddInteger(2).AddInteger(3)
assert.Equal(b, 3, root.GetArray("k1").Len())
assert.Equal(b, `{"k1":[1,2,3]}`, root.Marshal())
assert.Equal(b, "[0,0]0[1,1]1[2,1]2[3,1]3", root.GetArray("k1").ToTestString())
assert.Equal(b, "[0,0,1]0[1,1,2]1[2,1,3]2[3,1,4]3", root.GetArray("k1").ToTestString())

root.GetArray("k1").Delete(1)
assert.Equal(b, `{"k1":[1,3]}`, root.Marshal())
assert.Equal(b, 2, root.GetArray("k1").Len())
assert.Equal(b, "[0,0]0[1,1]1[2,0]2[1,1]3", root.GetArray("k1").ToTestString())
assert.Equal(b, "[0,0,1]0[1,1,2]1[2,0,3]2[1,1,1]3", root.GetArray("k1").ToTestString())

root.GetArray("k1").InsertIntegerAfter(0, 2)
assert.Equal(b, `{"k1":[1,2,3]}`, root.Marshal())
assert.Equal(b, 3, root.GetArray("k1").Len())
assert.Equal(b, "[0,0]0[1,1]1[3,1]2[1,0]2[1,1]3", root.GetArray("k1").ToTestString())
assert.Equal(b, "[0,0,1]0[1,1,2]1[3,1,3]2[1,0,2]2[1,1,1]3", root.GetArray("k1").ToTestString())

root.GetArray("k1").InsertIntegerAfter(2, 4)
assert.Equal(b, `{"k1":[1,2,3,4]}`, root.Marshal())
assert.Equal(b, 4, root.GetArray("k1").Len())
assert.Equal(b, "[0,0]0[1,1]1[2,1]2[2,0]2[3,1]3[4,1]4", root.GetArray("k1").ToTestString())
assert.Equal(b, "[0,0,1]0[1,1,2]1[2,1,3]2[2,0,4]2[3,1,5]3[4,1,6]4", root.GetArray("k1").ToTestString())

for i := 0; i < root.GetArray("k1").Len(); i++ {
assert.Equal(
Expand Down
Loading