From dc586c25206a4b41a7d8c505e3700f5704134228 Mon Sep 17 00:00:00 2001 From: Luke Shumaker Date: Thu, 5 Jan 2023 19:20:25 -0700 Subject: containers: Add SyncValue and SyncPool types --- lib/containers/syncpool.go | 33 ++++++++++++++++++++++ lib/containers/syncvalue.go | 67 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 100 insertions(+) create mode 100644 lib/containers/syncpool.go create mode 100644 lib/containers/syncvalue.go (limited to 'lib/containers') diff --git a/lib/containers/syncpool.go b/lib/containers/syncpool.go new file mode 100644 index 0000000..cb5398d --- /dev/null +++ b/lib/containers/syncpool.go @@ -0,0 +1,33 @@ +// Copyright (C) 2022-2023 Luke Shumaker +// +// 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 new file mode 100644 index 0000000..160db3c --- /dev/null +++ b/lib/containers/syncvalue.go @@ -0,0 +1,67 @@ +// Copyright (C) 2022-2023 Luke Shumaker +// +// 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 +} -- cgit v1.2.3-2-g168b From f4f062d7d4ed730411e04ecd36ee36387e50739c Mon Sep 17 00:00:00 2001 From: Luke Shumaker Date: Thu, 26 Jan 2023 01:08:22 -0700 Subject: Upgrade to lowmemjson v0.2.0 --- lib/containers/set.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'lib/containers') diff --git a/lib/containers/set.go b/lib/containers/set.go index 4fc8aad..b2af494 100644 --- a/lib/containers/set.go +++ b/lib/containers/set.go @@ -71,7 +71,7 @@ func (o Set[T]) EncodeJSON(w io.Writer) error { return less(keys[i], keys[j]) }) - return lowmemjson.Encode(w, keys) + return lowmemjson.NewEncoder(w).Encode(keys) } func (o *Set[T]) DecodeJSON(r io.RuneScanner) error { @@ -87,7 +87,7 @@ func (o *Set[T]) DecodeJSON(r io.RuneScanner) error { *o = Set[T]{} return lowmemjson.DecodeArray(r, func(r io.RuneScanner) error { var val T - if err := lowmemjson.Decode(r, &val); err != nil { + if err := lowmemjson.NewDecoder(r).Decode(&val); err != nil { return err } (*o)[val] = struct{}{} -- cgit v1.2.3-2-g168b From 86063b41fc1a235930d6c79e6b7cd38ae8d8c147 Mon Sep 17 00:00:00 2001 From: Luke Shumaker Date: Thu, 26 Jan 2023 14:53:37 -0700 Subject: Split lib/containers.Sync* to git.lukeshu.com/go/typedsync --- lib/containers/syncmap.go | 53 ----------------------------------- lib/containers/syncpool.go | 33 ---------------------- lib/containers/syncvalue.go | 67 --------------------------------------------- 3 files changed, 153 deletions(-) delete mode 100644 lib/containers/syncmap.go delete mode 100644 lib/containers/syncpool.go delete mode 100644 lib/containers/syncvalue.go (limited to 'lib/containers') 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 -// -// 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 -// -// 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 -// -// 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 -} -- cgit v1.2.3-2-g168b