56c21c6bd6
Some test files failed to build as the go module "replace" doesn't work with test and internal packages yet. The other tests need updates to the testdata.
137 lines
4.1 KiB
Go
137 lines
4.1 KiB
Go
// Copyright (c) 2015-2016 The btcsuite developers
|
|
// Use of this source code is governed by an ISC
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package treap
|
|
|
|
import (
|
|
"math/rand"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
// staticDepth is the size of the static array to use for keeping track
|
|
// of the parent stack during treap iteration. Since a treap has a very
|
|
// high probability that the tree height is logarithmic, it is
|
|
// exceedingly unlikely that the parent stack will ever exceed this size
|
|
// even for extremely large numbers of items.
|
|
staticDepth = 128
|
|
|
|
// nodeFieldsSize is the size the fields of each node takes excluding
|
|
// the contents of the key and value. It assumes 64-bit pointers so
|
|
// technically it is smaller on 32-bit platforms, but overestimating the
|
|
// size in that case is acceptable since it avoids the need to import
|
|
// unsafe. It consists of 24-bytes for each key and value + 8 bytes for
|
|
// each of the priority, left, and right fields (24*2 + 8*3).
|
|
nodeFieldsSize = 72
|
|
)
|
|
|
|
var (
|
|
// emptySlice is used for keys that have no value associated with them
|
|
// so callers can distinguish between a key that does not exist and one
|
|
// that has no value associated with it.
|
|
emptySlice = make([]byte, 0)
|
|
)
|
|
|
|
// treapNode represents a node in the treap.
|
|
type treapNode struct {
|
|
key []byte
|
|
value []byte
|
|
priority int
|
|
left *treapNode
|
|
right *treapNode
|
|
}
|
|
|
|
// nodeSize returns the number of bytes the specified node occupies including
|
|
// the struct fields and the contents of the key and value.
|
|
func nodeSize(node *treapNode) uint64 {
|
|
return nodeFieldsSize + uint64(len(node.key)+len(node.value))
|
|
}
|
|
|
|
// newTreapNode returns a new node from the given key, value, and priority. The
|
|
// node is not initially linked to any others.
|
|
func newTreapNode(key, value []byte, priority int) *treapNode {
|
|
return &treapNode{key: key, value: value, priority: priority}
|
|
}
|
|
|
|
// parentStack represents a stack of parent treap nodes that are used during
|
|
// iteration. It consists of a static array for holding the parents and a
|
|
// dynamic overflow slice. It is extremely unlikely the overflow will ever be
|
|
// hit during normal operation, however, since a treap's height is
|
|
// probabilistic, the overflow case needs to be handled properly. This approach
|
|
// is used because it is much more efficient for the majority case than
|
|
// dynamically allocating heap space every time the treap is iterated.
|
|
type parentStack struct {
|
|
index int
|
|
items [staticDepth]*treapNode
|
|
overflow []*treapNode
|
|
}
|
|
|
|
// Len returns the current number of items in the stack.
|
|
func (s *parentStack) Len() int {
|
|
return s.index
|
|
}
|
|
|
|
// At returns the item n number of items from the top of the stack, where 0 is
|
|
// the topmost item, without removing it. It returns nil if n exceeds the
|
|
// number of items on the stack.
|
|
func (s *parentStack) At(n int) *treapNode {
|
|
index := s.index - n - 1
|
|
if index < 0 {
|
|
return nil
|
|
}
|
|
|
|
if index < staticDepth {
|
|
return s.items[index]
|
|
}
|
|
|
|
return s.overflow[index-staticDepth]
|
|
}
|
|
|
|
// Pop removes the top item from the stack. It returns nil if the stack is
|
|
// empty.
|
|
func (s *parentStack) Pop() *treapNode {
|
|
if s.index == 0 {
|
|
return nil
|
|
}
|
|
|
|
s.index--
|
|
if s.index < staticDepth {
|
|
node := s.items[s.index]
|
|
s.items[s.index] = nil
|
|
return node
|
|
}
|
|
|
|
node := s.overflow[s.index-staticDepth]
|
|
s.overflow[s.index-staticDepth] = nil
|
|
return node
|
|
}
|
|
|
|
// Push pushes the passed item onto the top of the stack.
|
|
func (s *parentStack) Push(node *treapNode) {
|
|
if s.index < staticDepth {
|
|
s.items[s.index] = node
|
|
s.index++
|
|
return
|
|
}
|
|
|
|
// This approach is used over append because reslicing the slice to pop
|
|
// the item causes the compiler to make unneeded allocations. Also,
|
|
// since the max number of items is related to the tree depth which
|
|
// requires expontentially more items to increase, only increase the cap
|
|
// one item at a time. This is more intelligent than the generic append
|
|
// expansion algorithm which often doubles the cap.
|
|
index := s.index - staticDepth
|
|
if index+1 > cap(s.overflow) {
|
|
overflow := make([]*treapNode, index+1)
|
|
copy(overflow, s.overflow)
|
|
s.overflow = overflow
|
|
}
|
|
s.overflow[index] = node
|
|
s.index++
|
|
}
|
|
|
|
func init() {
|
|
rand.Seed(time.Now().UnixNano())
|
|
}
|