77 lines
1.5 KiB
Go
77 lines
1.5 KiB
Go
package stm
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"github.com/alecthomas/atomic"
|
|
)
|
|
|
|
// Holds an STM variable.
|
|
type Var[T any] struct {
|
|
value atomic.Value[VarValue]
|
|
watchers sync.Map
|
|
mu sync.Mutex
|
|
}
|
|
|
|
func (v *Var[T]) getValue() *atomic.Value[VarValue] {
|
|
return &v.value
|
|
}
|
|
|
|
func (v *Var[T]) getWatchers() *sync.Map {
|
|
return &v.watchers
|
|
}
|
|
|
|
func (v *Var[T]) getLock() *sync.Mutex {
|
|
return &v.mu
|
|
}
|
|
|
|
func (v *Var[T]) changeValue(new any) {
|
|
old := v.value.Load()
|
|
newVarValue := old.Set(new)
|
|
v.value.Store(newVarValue)
|
|
if old.Changed(newVarValue) {
|
|
go v.wakeWatchers(newVarValue)
|
|
}
|
|
}
|
|
|
|
func (v *Var[T]) wakeWatchers(new VarValue) {
|
|
v.watchers.Range(func(k, _ any) bool {
|
|
tx := k.(*Tx)
|
|
// We have to lock here to ensure that the Tx is waiting before we signal it. Otherwise we
|
|
// could signal it before it goes to sleep and it will miss the notification.
|
|
tx.mu.Lock()
|
|
if read := tx.reads[v]; read != nil && read.Changed(new) {
|
|
tx.cond.Broadcast()
|
|
for !tx.waiting && !tx.completed {
|
|
tx.cond.Wait()
|
|
}
|
|
}
|
|
tx.mu.Unlock()
|
|
return !v.value.Load().Changed(new)
|
|
})
|
|
}
|
|
|
|
// Returns a new STM variable.
|
|
func NewVar[T any](val T) *Var[T] {
|
|
v := &Var[T]{}
|
|
v.value.Store(versionedValue[T]{
|
|
value: val,
|
|
})
|
|
return v
|
|
}
|
|
|
|
func NewCustomVar[T any](val T, changed func(T, T) bool) *Var[T] {
|
|
v := &Var[T]{}
|
|
v.value.Store(customVarValue[T]{
|
|
value: val,
|
|
changed: changed,
|
|
})
|
|
return v
|
|
}
|
|
|
|
func NewBuiltinEqVar[T comparable](val T) *Var[T] {
|
|
return NewCustomVar(val, func(a, b T) bool {
|
|
return a != b
|
|
})
|
|
}
|