mirror of
https://github.com/KusakabeShi/EtherGuard-VPN.git
synced 2024-11-25 08:43:08 +01:00
c3bde5f590
Here is the old implementation:
type WaitPool struct {
c chan interface{}
}
func NewWaitPool(max uint32, new func() interface{}) *WaitPool {
p := &WaitPool{c: make(chan interface{}, max)}
for i := uint32(0); i < max; i++ {
p.c <- new()
}
return p
}
func (p *WaitPool) Get() interface{} {
return <- p.c
}
func (p *WaitPool) Put(x interface{}) {
p.c <- x
}
It performs worse than the new one:
name old time/op new time/op delta
WaitPool-16 16.4µs ± 5% 15.1µs ± 3% -7.86% (p=0.008 n=5+5)
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
83 lines
1.6 KiB
Go
83 lines
1.6 KiB
Go
/* SPDX-License-Identifier: MIT
|
|
*
|
|
* Copyright (C) 2019-2021 WireGuard LLC. All Rights Reserved.
|
|
*/
|
|
|
|
package device
|
|
|
|
import (
|
|
"math/rand"
|
|
"runtime"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestWaitPool(t *testing.T) {
|
|
var wg sync.WaitGroup
|
|
trials := int32(100000)
|
|
workers := runtime.NumCPU() + 2
|
|
if workers-4 <= 0 {
|
|
t.Skip("Not enough cores")
|
|
}
|
|
p := NewWaitPool(uint32(workers-4), func() interface{} { return make([]byte, 16) })
|
|
wg.Add(workers)
|
|
max := uint32(0)
|
|
updateMax := func() {
|
|
count := atomic.LoadUint32(&p.count)
|
|
if count > p.max {
|
|
t.Errorf("count (%d) > max (%d)", count, p.max)
|
|
}
|
|
for {
|
|
old := atomic.LoadUint32(&max)
|
|
if count <= old {
|
|
break
|
|
}
|
|
if atomic.CompareAndSwapUint32(&max, old, count) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
for i := 0; i < workers; i++ {
|
|
go func() {
|
|
defer wg.Done()
|
|
for atomic.AddInt32(&trials, -1) > 0 {
|
|
updateMax()
|
|
x := p.Get()
|
|
updateMax()
|
|
time.Sleep(time.Duration(rand.Intn(100)) * time.Microsecond)
|
|
updateMax()
|
|
p.Put(x)
|
|
updateMax()
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
if max != p.max {
|
|
t.Errorf("Actual maximum count (%d) != ideal maximum count (%d)", max, p.max)
|
|
}
|
|
}
|
|
|
|
func BenchmarkWaitPool(b *testing.B) {
|
|
var wg sync.WaitGroup
|
|
trials := int32(b.N)
|
|
workers := runtime.NumCPU() + 2
|
|
if workers-4 <= 0 {
|
|
b.Skip("Not enough cores")
|
|
}
|
|
p := NewWaitPool(uint32(workers-4), func() interface{} { return make([]byte, 16) })
|
|
wg.Add(workers)
|
|
b.ResetTimer()
|
|
for i := 0; i < workers; i++ {
|
|
go func() {
|
|
defer wg.Done()
|
|
for atomic.AddInt32(&trials, -1) > 0 {
|
|
x := p.Get()
|
|
time.Sleep(time.Duration(rand.Intn(100)) * time.Microsecond)
|
|
p.Put(x)
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
} |