mirror of
https://github.com/restic/restic.git
synced 2024-08-22 12:23:29 +02:00
217 lines
4.8 KiB
Go
217 lines
4.8 KiB
Go
// Copyright 2016 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package syncmap_test
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"sync/atomic"
|
|
"testing"
|
|
|
|
"golang.org/x/sync/syncmap"
|
|
)
|
|
|
|
type bench struct {
|
|
setup func(*testing.B, mapInterface)
|
|
perG func(b *testing.B, pb *testing.PB, i int, m mapInterface)
|
|
}
|
|
|
|
func benchMap(b *testing.B, bench bench) {
|
|
for _, m := range [...]mapInterface{&DeepCopyMap{}, &RWMutexMap{}, &syncmap.Map{}} {
|
|
b.Run(fmt.Sprintf("%T", m), func(b *testing.B) {
|
|
m = reflect.New(reflect.TypeOf(m).Elem()).Interface().(mapInterface)
|
|
if bench.setup != nil {
|
|
bench.setup(b, m)
|
|
}
|
|
|
|
b.ResetTimer()
|
|
|
|
var i int64
|
|
b.RunParallel(func(pb *testing.PB) {
|
|
id := int(atomic.AddInt64(&i, 1) - 1)
|
|
bench.perG(b, pb, id*b.N, m)
|
|
})
|
|
})
|
|
}
|
|
}
|
|
|
|
func BenchmarkLoadMostlyHits(b *testing.B) {
|
|
const hits, misses = 1023, 1
|
|
|
|
benchMap(b, bench{
|
|
setup: func(_ *testing.B, m mapInterface) {
|
|
for i := 0; i < hits; i++ {
|
|
m.LoadOrStore(i, i)
|
|
}
|
|
// Prime the map to get it into a steady state.
|
|
for i := 0; i < hits*2; i++ {
|
|
m.Load(i % hits)
|
|
}
|
|
},
|
|
|
|
perG: func(b *testing.B, pb *testing.PB, i int, m mapInterface) {
|
|
for ; pb.Next(); i++ {
|
|
m.Load(i % (hits + misses))
|
|
}
|
|
},
|
|
})
|
|
}
|
|
|
|
func BenchmarkLoadMostlyMisses(b *testing.B) {
|
|
const hits, misses = 1, 1023
|
|
|
|
benchMap(b, bench{
|
|
setup: func(_ *testing.B, m mapInterface) {
|
|
for i := 0; i < hits; i++ {
|
|
m.LoadOrStore(i, i)
|
|
}
|
|
// Prime the map to get it into a steady state.
|
|
for i := 0; i < hits*2; i++ {
|
|
m.Load(i % hits)
|
|
}
|
|
},
|
|
|
|
perG: func(b *testing.B, pb *testing.PB, i int, m mapInterface) {
|
|
for ; pb.Next(); i++ {
|
|
m.Load(i % (hits + misses))
|
|
}
|
|
},
|
|
})
|
|
}
|
|
|
|
func BenchmarkLoadOrStoreBalanced(b *testing.B) {
|
|
const hits, misses = 128, 128
|
|
|
|
benchMap(b, bench{
|
|
setup: func(b *testing.B, m mapInterface) {
|
|
if _, ok := m.(*DeepCopyMap); ok {
|
|
b.Skip("DeepCopyMap has quadratic running time.")
|
|
}
|
|
for i := 0; i < hits; i++ {
|
|
m.LoadOrStore(i, i)
|
|
}
|
|
// Prime the map to get it into a steady state.
|
|
for i := 0; i < hits*2; i++ {
|
|
m.Load(i % hits)
|
|
}
|
|
},
|
|
|
|
perG: func(b *testing.B, pb *testing.PB, i int, m mapInterface) {
|
|
for ; pb.Next(); i++ {
|
|
j := i % (hits + misses)
|
|
if j < hits {
|
|
if _, ok := m.LoadOrStore(j, i); !ok {
|
|
b.Fatalf("unexpected miss for %v", j)
|
|
}
|
|
} else {
|
|
if v, loaded := m.LoadOrStore(i, i); loaded {
|
|
b.Fatalf("failed to store %v: existing value %v", i, v)
|
|
}
|
|
}
|
|
}
|
|
},
|
|
})
|
|
}
|
|
|
|
func BenchmarkLoadOrStoreUnique(b *testing.B) {
|
|
benchMap(b, bench{
|
|
setup: func(b *testing.B, m mapInterface) {
|
|
if _, ok := m.(*DeepCopyMap); ok {
|
|
b.Skip("DeepCopyMap has quadratic running time.")
|
|
}
|
|
},
|
|
|
|
perG: func(b *testing.B, pb *testing.PB, i int, m mapInterface) {
|
|
for ; pb.Next(); i++ {
|
|
m.LoadOrStore(i, i)
|
|
}
|
|
},
|
|
})
|
|
}
|
|
|
|
func BenchmarkLoadOrStoreCollision(b *testing.B) {
|
|
benchMap(b, bench{
|
|
setup: func(_ *testing.B, m mapInterface) {
|
|
m.LoadOrStore(0, 0)
|
|
},
|
|
|
|
perG: func(b *testing.B, pb *testing.PB, i int, m mapInterface) {
|
|
for ; pb.Next(); i++ {
|
|
m.LoadOrStore(0, 0)
|
|
}
|
|
},
|
|
})
|
|
}
|
|
|
|
func BenchmarkRange(b *testing.B) {
|
|
const mapSize = 1 << 10
|
|
|
|
benchMap(b, bench{
|
|
setup: func(_ *testing.B, m mapInterface) {
|
|
for i := 0; i < mapSize; i++ {
|
|
m.Store(i, i)
|
|
}
|
|
},
|
|
|
|
perG: func(b *testing.B, pb *testing.PB, i int, m mapInterface) {
|
|
for ; pb.Next(); i++ {
|
|
m.Range(func(_, _ interface{}) bool { return true })
|
|
}
|
|
},
|
|
})
|
|
}
|
|
|
|
// BenchmarkAdversarialAlloc tests performance when we store a new value
|
|
// immediately whenever the map is promoted to clean and otherwise load a
|
|
// unique, missing key.
|
|
//
|
|
// This forces the Load calls to always acquire the map's mutex.
|
|
func BenchmarkAdversarialAlloc(b *testing.B) {
|
|
benchMap(b, bench{
|
|
perG: func(b *testing.B, pb *testing.PB, i int, m mapInterface) {
|
|
var stores, loadsSinceStore int64
|
|
for ; pb.Next(); i++ {
|
|
m.Load(i)
|
|
if loadsSinceStore++; loadsSinceStore > stores {
|
|
m.LoadOrStore(i, stores)
|
|
loadsSinceStore = 0
|
|
stores++
|
|
}
|
|
}
|
|
},
|
|
})
|
|
}
|
|
|
|
// BenchmarkAdversarialDelete tests performance when we periodically delete
|
|
// one key and add a different one in a large map.
|
|
//
|
|
// This forces the Load calls to always acquire the map's mutex and periodically
|
|
// makes a full copy of the map despite changing only one entry.
|
|
func BenchmarkAdversarialDelete(b *testing.B) {
|
|
const mapSize = 1 << 10
|
|
|
|
benchMap(b, bench{
|
|
setup: func(_ *testing.B, m mapInterface) {
|
|
for i := 0; i < mapSize; i++ {
|
|
m.Store(i, i)
|
|
}
|
|
},
|
|
|
|
perG: func(b *testing.B, pb *testing.PB, i int, m mapInterface) {
|
|
for ; pb.Next(); i++ {
|
|
m.Load(i)
|
|
|
|
if i%mapSize == 0 {
|
|
m.Range(func(k, _ interface{}) bool {
|
|
m.Delete(k)
|
|
return false
|
|
})
|
|
m.Store(i, i)
|
|
}
|
|
}
|
|
},
|
|
})
|
|
}
|