summaryrefslogtreecommitdiff
path: root/lib/containers
diff options
context:
space:
mode:
authorLuke Shumaker <lukeshu@lukeshu.com>2023-01-26 12:23:15 -0700
committerLuke Shumaker <lukeshu@lukeshu.com>2023-01-26 12:46:07 -0700
commit716dd31f7cf52d9772fd4ed687f9cdc921443a35 (patch)
treeded6651a3b6e240f60759465af9abccd52d5984d /lib/containers
parent774689062b4ac1921434a6c7a2ac78b8f29ac85a (diff)
Set up as a separate repov0.0.1
Diffstat (limited to 'lib/containers')
-rw-r--r--lib/containers/syncmap.go53
-rw-r--r--lib/containers/syncpool.go33
-rw-r--r--lib/containers/syncvalue.go67
3 files changed, 0 insertions, 153 deletions
diff --git a/lib/containers/syncmap.go b/lib/containers/syncmap.go
deleted file mode 100644
index 74da4b3..0000000
--- a/lib/containers/syncmap.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (C) 2022-2023 Luke Shumaker <lukeshu@lukeshu.com>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package containers
-
-import (
- "sync"
-)
-
-type SyncMap[K comparable, V any] struct {
- inner sync.Map
-}
-
-func (m *SyncMap[K, V]) Delete(key K) {
- m.inner.Delete(key)
-}
-
-func (m *SyncMap[K, V]) Load(key K) (value V, ok bool) {
- _value, ok := m.inner.Load(key)
- if ok {
- //nolint:forcetypeassert // Typed wrapper around untyped lib.
- value = _value.(V)
- }
- return value, ok
-}
-
-func (m *SyncMap[K, V]) LoadAndDelete(key K) (value V, loaded bool) {
- _value, ok := m.inner.LoadAndDelete(key)
- if ok {
- //nolint:forcetypeassert // Typed wrapper around untyped lib.
- value = _value.(V)
- }
- return value, ok
-}
-
-func (m *SyncMap[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
- _actual, loaded := m.inner.LoadOrStore(key, value)
- //nolint:forcetypeassert // Typed wrapper around untyped lib.
- actual = _actual.(V)
- return actual, loaded
-}
-
-func (m *SyncMap[K, V]) Range(f func(key K, value V) bool) {
- m.inner.Range(func(key, value any) bool {
- //nolint:forcetypeassert // Typed wrapper around untyped lib.
- return f(key.(K), value.(V))
- })
-}
-
-func (m *SyncMap[K, V]) Store(key K, value V) {
- m.inner.Store(key, value)
-}
diff --git a/lib/containers/syncpool.go b/lib/containers/syncpool.go
deleted file mode 100644
index cb5398d..0000000
--- a/lib/containers/syncpool.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (C) 2022-2023 Luke Shumaker <lukeshu@lukeshu.com>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package containers
-
-import (
- "sync"
-)
-
-type SyncPool[T any] struct {
- New func() T
-
- inner sync.Pool
-}
-
-func (p *SyncPool[T]) Get() (val T, ok bool) {
- _val := p.inner.Get()
- switch {
- case _val != nil:
- //nolint:forcetypeassert // Typed wrapper around untyped lib.
- return _val.(T), true
- case p.New != nil:
- return p.New(), true
- default:
- var zero T
- return zero, false
- }
-}
-
-func (p *SyncPool[T]) Put(val T) {
- p.inner.Put(val)
-}
diff --git a/lib/containers/syncvalue.go b/lib/containers/syncvalue.go
deleted file mode 100644
index 160db3c..0000000
--- a/lib/containers/syncvalue.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (C) 2022-2023 Luke Shumaker <lukeshu@lukeshu.com>
-//
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-package containers
-
-import (
- "sync"
-)
-
-// SyncValue is a typed equivalent of sync/atomic.Value.
-//
-// It is not actually a wrapper around sync/atomic.Value for
-// allocation-performance reasons.
-type SyncValue[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 SyncPool 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 *SyncValue[T]) Load() (val T, ok bool) {
- v.mu.Lock()
- defer v.mu.Unlock()
- return v.val, v.ok
-}
-
-func (v *SyncValue[T]) Store(val T) {
- v.mu.Lock()
- defer v.mu.Unlock()
- v.val, v.ok = val, true
-}
-
-func (v *SyncValue[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 *SyncValue[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
-}