part: options as bitfield

Signed-off-by: Jussi Maki <[email protected]>

Author: joamaki

part/node.go

@@ -444,12 +444,12 @@ type leaf[T any] struct {
 	key   []byte
 }
 
-func newLeaf[T any](o *options, prefix, key []byte, value T) *leaf[T] {
+func newLeaf[T any](o options, prefix, key []byte, value T) *leaf[T] {
 	leaf := &leaf[T]{key: key, value: value}
 	leaf.setPrefix(prefix)
 	leaf.setKind(nodeKindLeaf)
 
-	if !o.rootOnlyWatch {
+	if !o.rootOnlyWatch() {
 		leaf.watch = make(chan struct{})
 	}
 

part/options.go

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Authors of Cilium
+
+package part
+
+type options uint8
+
+const (
+	rootOnlyWatchOpt = options(1 << 1)
+	noCacheOpt       = options(1 << 2)
+)
+
+func (o *options) setRootOnlyWatch() {
+	*o |= rootOnlyWatchOpt
+}
+
+func (o *options) setNoCache() {
+	*o |= noCacheOpt
+
+}
+func (o options) rootOnlyWatch() bool {
+	return o&rootOnlyWatchOpt != 0
+}
+
+func (o options) noCache() bool {
+	return o&noCacheOpt != 0
+}

part/part_test.go

@@ -1066,7 +1066,11 @@ func Benchmark_Replace_RootOnlyWatch(b *testing.B) {
 }
 
 func benchmark_Replace(b *testing.B, watching bool) {
-	tree := New[int](RootOnlyWatch)
+	var opts []Option
+	if watching {
+		opts = append(opts, RootOnlyWatch)
+	}
+	tree := New[int](opts...)
 	txn := tree.Txn()
 	for i := range numObjectsToInsert {
 		key := binary.BigEndian.AppendUint32(nil, uint32(numObjectsToInsert+i))

part/tree.go

@@ -9,10 +9,10 @@ package part
 // has an associated channel that is closed when that node is mutated.
 // This allows watching any part of the tree (any prefix) for changes.
 type Tree[T any] struct {
-	opts *options
 	root *header[T]
 	txn  *Txn[T]
 	size int // the number of objects in the tree
+	opts options
 }
 
 // New constructs a new tree.
@@ -24,10 +24,10 @@ func New[T any](opts ...Option) *Tree[T] {
 	t := &Tree[T]{
 		root: newNode4[T](),
 		size: 0,
-		opts: &o,
+		opts: o,
 	}
-	if !o.noCache {
-		t.txn = newTxn[T](&o)
+	if !o.noCache() {
+		t.txn = newTxn[T](o)
 	}
 	return t
 }
@@ -37,16 +37,16 @@ type Option func(*options)
 // RootOnlyWatch sets the tree to only have a watch channel on the root
 // node. This improves the speed at the cost of having a much more coarse
 // grained notifications.
-func RootOnlyWatch(o *options) { o.rootOnlyWatch = true }
+var RootOnlyWatch = (*options).setRootOnlyWatch
 
 // NoCache disables the mutated node cache
-func NoCache(o *options) { o.noCache = true }
+var NoCache = (*options).setNoCache
 
-func newTxn[T any](o *options) *Txn[T] {
+func newTxn[T any](o options) *Txn[T] {
 	txn := &Txn[T]{
 		watches: make(map[chan struct{}]struct{}),
 	}
-	if !o.noCache {
+	if !o.noCache() {
 		txn.mutated = &nodeMutated{}
 		txn.deleteParentsCache = make([]deleteParent[T], 0, 32)
 	}
@@ -83,7 +83,7 @@ func (t *Tree[T]) Len() int {
 // value was found.
 func (t *Tree[T]) Get(key []byte) (T, <-chan struct{}, bool) {
 	value, watch, ok := search(t.root, key)
-	if t.opts.rootOnlyWatch {
+	if t.opts.rootOnlyWatch() {
 		watch = t.root.watch
 	}
 	return value, watch, ok
@@ -94,7 +94,7 @@ func (t *Tree[T]) Get(key []byte) (T, <-chan struct{}, bool) {
 // the given prefix are upserted or deleted.
 func (t *Tree[T]) Prefix(prefix []byte) (*Iterator[T], <-chan struct{}) {
 	iter, watch := prefixSearch(t.root, prefix)
-	if t.opts.rootOnlyWatch {
+	if t.opts.rootOnlyWatch() {
 		watch = t.root.watch
 	}
 	return iter, watch
@@ -151,8 +151,3 @@ func (t *Tree[T]) Iterator() *Iterator[T] {
 func (t *Tree[T]) PrintTree() {
 	t.root.printTree(0)
 }
-
-type options struct {
-	rootOnlyWatch bool
-	noCache       bool
-}

part/txn.go

@@ -10,8 +10,8 @@ import (
 // Txn is a transaction against a tree. It allows doing efficient
 // modifications to a tree by caching and reusing cloned nodes.
 type Txn[T any] struct {
-	opts *options
 	root *header[T]
+	opts options
 	size int // the number of objects in the tree
 
 	// mutated is the set of nodes mutated in this transaction
@@ -63,7 +63,7 @@ func (txn *Txn[T]) InsertWatch(key []byte, value T) (old T, hadOld bool, watch <
 	if !hadOld {
 		txn.size++
 	}
-	if txn.opts.rootOnlyWatch {
+	if txn.opts.rootOnlyWatch() {
 		watch = txn.root.watch
 	}
 	return
@@ -88,7 +88,7 @@ func (txn *Txn[T]) ModifyWatch(key []byte, mod func(T) T) (old T, hadOld bool, w
 	if !hadOld {
 		txn.size++
 	}
-	if txn.opts.rootOnlyWatch {
+	if txn.opts.rootOnlyWatch() {
 		watch = txn.root.watch
 	}
 	return
@@ -117,7 +117,7 @@ func (txn *Txn[T]) RootWatch() <-chan struct{} {
 // value was found.
 func (txn *Txn[T]) Get(key []byte) (T, <-chan struct{}, bool) {
 	value, watch, ok := search(txn.root, key)
-	if txn.opts.rootOnlyWatch {
+	if txn.opts.rootOnlyWatch() {
 		watch = txn.root.watch
 	}
 	return value, watch, ok
@@ -129,7 +129,7 @@ func (txn *Txn[T]) Get(key []byte) (T, <-chan struct{}, bool) {
 func (txn *Txn[T]) Prefix(key []byte) (*Iterator[T], <-chan struct{}) {
 	txn.mutated.clear()
 	iter, watch := prefixSearch(txn.root, key)
-	if txn.opts.rootOnlyWatch {
+	if txn.opts.rootOnlyWatch() {
 		watch = txn.root.watch
 	}
 	return iter, watch
@@ -160,7 +160,7 @@ func (txn *Txn[T]) Commit() *Tree[T] {
 // Tree.Txn().
 func (txn *Txn[T]) CommitOnly() *Tree[T] {
 	t := &Tree[T]{opts: txn.opts, root: txn.root, size: txn.size}
-	if !txn.opts.noCache {
+	if !txn.opts.noCache() {
 		t.txn = txn
 	}
 	return t
@@ -188,7 +188,7 @@ func (txn *Txn[T]) cloneNode(n *header[T]) *header[T] {
 	if n.watch != nil {
 		txn.watches[n.watch] = struct{}{}
 	}
-	n = n.clone(!txn.opts.rootOnlyWatch || n == txn.root)
+	n = n.clone(!txn.opts.rootOnlyWatch() || n == txn.root)
 	nodeMutatedSet(txn.mutated, n)
 	return n
 }
@@ -225,7 +225,7 @@ func (txn *Txn[T]) modify(root *header[T], key []byte, mod func(T) T) (oldValue
 				if this.watch != nil {
 					txn.watches[this.watch] = struct{}{}
 				}
-				this = this.promote(!txn.opts.rootOnlyWatch || this == root)
+				this = this.promote(!txn.opts.rootOnlyWatch() || this == root)
 				nodeMutatedSet(txn.mutated, this)
 			} else {
 				// Node is big enough, clone it so we can mutate it
@@ -298,7 +298,7 @@ func (txn *Txn[T]) modify(root *header[T], key []byte, mod func(T) T) (oldValue
 	newNode := &node4[T]{}
 	newNode.setPrefix(common)
 	newNode.setKind(nodeKind4)
-	if !txn.opts.rootOnlyWatch {
+	if !txn.opts.rootOnlyWatch() {
 		newNode.watch = make(chan struct{})
 	}