summaryrefslogtreecommitdiff
path: root/value.go
diff options
context:
space:
mode:
Diffstat (limited to 'value.go')
-rw-r--r--value.go67
1 files changed, 67 insertions, 0 deletions
diff --git a/value.go b/value.go
new file mode 100644
index 0000000..99c8876
--- /dev/null
+++ b/value.go
@@ -0,0 +1,67 @@
+// Copyright (C) 2022-2023 Luke Shumaker <lukeshu@lukeshu.com>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package typedsync
+
+import (
+ "sync"
+)
+
+// Value is a typed equivalent of sync/atomic.Value.
+//
+// It is not actually a wrapper around sync/atomic.Value for
+// allocation-performance reasons.
+type Value[T comparable] struct {
+ mu sync.Mutex
+ ok bool
+ val T
+}
+
+// This uses a dumb mutex-based solution because
+//
+// 1. Performance is good enough, because in the fast-path mutexes
+// use the same compare-and-swap as sync/atomic.Value; and because
+// all of these methods are short we're unlikely to hit the
+// mutex's slow path.
+//
+// 2. We could use sync/atomic.Pointer[T], which by itself would have
+// the same performance characteristics as sync/atomic.Value but
+// without the benefit of runtime_procPin()/runtime_procUnpin().
+// We want to avoid that because it means we're doing an
+// allocation for every store/swap; avoiding that is our whole
+// reason for not just wraping sync/atomic.Value. So then we'd
+// want to use a Pool to reuse allocations; but (1) that adds more
+// sync-overhead, and (2) it also gets trickier because we'd have
+// to be careful about not adding a pointer back to the pool when
+// load has grabbed the pointer but not yet dereferenced it.
+
+func (v *Value[T]) Load() (val T, ok bool) {
+ v.mu.Lock()
+ defer v.mu.Unlock()
+ return v.val, v.ok
+}
+
+func (v *Value[T]) Store(val T) {
+ v.mu.Lock()
+ defer v.mu.Unlock()
+ v.val, v.ok = val, true
+}
+
+func (v *Value[T]) Swap(newV T) (oldV T, oldOK bool) {
+ v.mu.Lock()
+ defer v.mu.Unlock()
+ oldV, oldOK = v.val, v.ok
+ v.val, v.ok = newV, true
+ return
+}
+
+func (v *Value[T]) CompareAndSwap(oldV, newV T) (swapped bool) {
+ v.mu.Lock()
+ defer v.mu.Unlock()
+ if !v.ok || v.val != oldV {
+ return false
+ }
+ v.val = newV
+ return true
+}