// the return from f “synchronizes before”
// the return from any call of once.Do(f).
type Once struct {
- m Mutex
// done indicates whether the action has been performed.
// It is first in the struct because it is used in the hot path.
// The hot path is inlined at every call site.
// Placing done first allows more compact instructions on some architectures (amd64/386),
// and fewer instructions (to calculate offset) on other architectures.
- done atomic.Bool
+ done uint32
+ m Mutex
}
// Do calls the function f if and only if Do is being called for the
func (o *Once) Do(f func()) {
// Note: Here is an incorrect implementation of Do:
//
- // if o.done.CompareAndSwap(false, true) {
+ // if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
// f()
// }
//
// call f, and the second would return immediately, without
// waiting for the first's call to f to complete.
// This is why the slow path falls back to a mutex, and why
- // the o.done.Store must be delayed until after f returns.
+ // the atomic.StoreUint32 must be delayed until after f returns.
- if !o.done.Load() {
+ if atomic.LoadUint32(&o.done) == 0 {
// Outlined slow-path to allow inlining of the fast-path.
o.doSlow(f)
}
func (o *Once) doSlow(f func()) {
o.m.Lock()
defer o.m.Unlock()
- if !o.done.Load() {
- defer o.done.Store(true)
+ if o.done == 0 {
+ defer atomic.StoreUint32(&o.done, 1)
f()
}
}
func small7() { // ERROR "can inline small7"
// the Do fast path should be inlined
- once.Do(small5) // ERROR "(inlining call to sync\.\(\*Once\)\.Do|inlining call to atomic\.\(\*Bool\)\.Load)"
+ once.Do(small5) // ERROR "inlining call to sync\.\(\*Once\)\.Do"
}
var rwmutex *sync.RWMutex