10172a64ce
Right now we generate hash functions for all types, just in case they
are used as map keys. That's a lot of wasted effort and binary size
for types which will never be used as a map key. Instead, generate
hash functions only for types that we know are map keys.
Just doing that is a bit too simple, since maps with an interface type
as a key might have to hash any concrete key type that implements that
interface. So for that case, implement hashing of such types at
runtime (instead of with generated code). It will be slower, but only
for maps with interface types as keys, and maybe only a bit slower as
the aeshash time probably dominates the dispatch time.
Reorg where we keep the equals and hash functions. Move the hash function
from the key type to the map type, saving a field in every non-map type.
That leaves only one function in the alg structure, so get rid of that and
just keep the equal function in the type descriptor itself.
While we're here, reorganize the rtype struct to more closely match
the gc version.
This is the gofrontend version of https://golang.org/cl/191198.
Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/212843
From-SVN: r279848
1236 lines
28 KiB
Go
1236 lines
28 KiB
Go
// Copyright 2013 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 runtime_test
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"reflect"
|
|
"runtime"
|
|
"runtime/internal/sys"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
)
|
|
|
|
func TestHmapSize(t *testing.T) {
|
|
// The structure of hmap is defined in runtime/map.go
|
|
// and in cmd/compile/internal/gc/reflect.go and must be in sync.
|
|
// The size of hmap should be 48 bytes on 64 bit and 28 bytes on 32 bit platforms.
|
|
var hmapSize = uintptr(8 + 5*sys.PtrSize)
|
|
if runtime.RuntimeHmapSize != hmapSize {
|
|
t.Errorf("sizeof(runtime.hmap{})==%d, want %d", runtime.RuntimeHmapSize, hmapSize)
|
|
}
|
|
|
|
}
|
|
|
|
// negative zero is a good test because:
|
|
// 1) 0 and -0 are equal, yet have distinct representations.
|
|
// 2) 0 is represented as all zeros, -0 isn't.
|
|
// I'm not sure the language spec actually requires this behavior,
|
|
// but it's what the current map implementation does.
|
|
func TestNegativeZero(t *testing.T) {
|
|
m := make(map[float64]bool, 0)
|
|
|
|
m[+0.0] = true
|
|
m[math.Copysign(0.0, -1.0)] = true // should overwrite +0 entry
|
|
|
|
if len(m) != 1 {
|
|
t.Error("length wrong")
|
|
}
|
|
|
|
for k := range m {
|
|
if math.Copysign(1.0, k) > 0 {
|
|
t.Error("wrong sign")
|
|
}
|
|
}
|
|
|
|
m = make(map[float64]bool, 0)
|
|
m[math.Copysign(0.0, -1.0)] = true
|
|
m[+0.0] = true // should overwrite -0.0 entry
|
|
|
|
if len(m) != 1 {
|
|
t.Error("length wrong")
|
|
}
|
|
|
|
for k := range m {
|
|
if math.Copysign(1.0, k) < 0 {
|
|
t.Error("wrong sign")
|
|
}
|
|
}
|
|
}
|
|
|
|
func testMapNan(t *testing.T, m map[float64]int) {
|
|
if len(m) != 3 {
|
|
t.Error("length wrong")
|
|
}
|
|
s := 0
|
|
for k, v := range m {
|
|
if k == k {
|
|
t.Error("nan disappeared")
|
|
}
|
|
if (v & (v - 1)) != 0 {
|
|
t.Error("value wrong")
|
|
}
|
|
s |= v
|
|
}
|
|
if s != 7 {
|
|
t.Error("values wrong")
|
|
}
|
|
}
|
|
|
|
// nan is a good test because nan != nan, and nan has
|
|
// a randomized hash value.
|
|
func TestMapAssignmentNan(t *testing.T) {
|
|
m := make(map[float64]int, 0)
|
|
nan := math.NaN()
|
|
|
|
// Test assignment.
|
|
m[nan] = 1
|
|
m[nan] = 2
|
|
m[nan] = 4
|
|
testMapNan(t, m)
|
|
}
|
|
|
|
// nan is a good test because nan != nan, and nan has
|
|
// a randomized hash value.
|
|
func TestMapOperatorAssignmentNan(t *testing.T) {
|
|
m := make(map[float64]int, 0)
|
|
nan := math.NaN()
|
|
|
|
// Test assignment operations.
|
|
m[nan] += 1
|
|
m[nan] += 2
|
|
m[nan] += 4
|
|
testMapNan(t, m)
|
|
}
|
|
|
|
func TestMapOperatorAssignment(t *testing.T) {
|
|
m := make(map[int]int, 0)
|
|
|
|
// "m[k] op= x" is rewritten into "m[k] = m[k] op x"
|
|
// differently when op is / or % than when it isn't.
|
|
// Simple test to make sure they all work as expected.
|
|
m[0] = 12345
|
|
m[0] += 67890
|
|
m[0] /= 123
|
|
m[0] %= 456
|
|
|
|
const want = (12345 + 67890) / 123 % 456
|
|
if got := m[0]; got != want {
|
|
t.Errorf("got %d, want %d", got, want)
|
|
}
|
|
}
|
|
|
|
var sinkAppend bool
|
|
|
|
func TestMapAppendAssignment(t *testing.T) {
|
|
m := make(map[int][]int, 0)
|
|
|
|
m[0] = nil
|
|
m[0] = append(m[0], 12345)
|
|
m[0] = append(m[0], 67890)
|
|
sinkAppend, m[0] = !sinkAppend, append(m[0], 123, 456)
|
|
a := []int{7, 8, 9, 0}
|
|
m[0] = append(m[0], a...)
|
|
|
|
want := []int{12345, 67890, 123, 456, 7, 8, 9, 0}
|
|
if got := m[0]; !reflect.DeepEqual(got, want) {
|
|
t.Errorf("got %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
// Maps aren't actually copied on assignment.
|
|
func TestAlias(t *testing.T) {
|
|
m := make(map[int]int, 0)
|
|
m[0] = 5
|
|
n := m
|
|
n[0] = 6
|
|
if m[0] != 6 {
|
|
t.Error("alias didn't work")
|
|
}
|
|
}
|
|
|
|
func TestGrowWithNaN(t *testing.T) {
|
|
m := make(map[float64]int, 4)
|
|
nan := math.NaN()
|
|
|
|
// Use both assignment and assignment operations as they may
|
|
// behave differently.
|
|
m[nan] = 1
|
|
m[nan] = 2
|
|
m[nan] += 4
|
|
|
|
cnt := 0
|
|
s := 0
|
|
growflag := true
|
|
for k, v := range m {
|
|
if growflag {
|
|
// force a hashtable resize
|
|
for i := 0; i < 50; i++ {
|
|
m[float64(i)] = i
|
|
}
|
|
for i := 50; i < 100; i++ {
|
|
m[float64(i)] += i
|
|
}
|
|
growflag = false
|
|
}
|
|
if k != k {
|
|
cnt++
|
|
s |= v
|
|
}
|
|
}
|
|
if cnt != 3 {
|
|
t.Error("NaN keys lost during grow")
|
|
}
|
|
if s != 7 {
|
|
t.Error("NaN values lost during grow")
|
|
}
|
|
}
|
|
|
|
type FloatInt struct {
|
|
x float64
|
|
y int
|
|
}
|
|
|
|
func TestGrowWithNegativeZero(t *testing.T) {
|
|
negzero := math.Copysign(0.0, -1.0)
|
|
m := make(map[FloatInt]int, 4)
|
|
m[FloatInt{0.0, 0}] = 1
|
|
m[FloatInt{0.0, 1}] += 2
|
|
m[FloatInt{0.0, 2}] += 4
|
|
m[FloatInt{0.0, 3}] = 8
|
|
growflag := true
|
|
s := 0
|
|
cnt := 0
|
|
negcnt := 0
|
|
// The first iteration should return the +0 key.
|
|
// The subsequent iterations should return the -0 key.
|
|
// I'm not really sure this is required by the spec,
|
|
// but it makes sense.
|
|
// TODO: are we allowed to get the first entry returned again???
|
|
for k, v := range m {
|
|
if v == 0 {
|
|
continue
|
|
} // ignore entries added to grow table
|
|
cnt++
|
|
if math.Copysign(1.0, k.x) < 0 {
|
|
if v&16 == 0 {
|
|
t.Error("key/value not updated together 1")
|
|
}
|
|
negcnt++
|
|
s |= v & 15
|
|
} else {
|
|
if v&16 == 16 {
|
|
t.Error("key/value not updated together 2", k, v)
|
|
}
|
|
s |= v
|
|
}
|
|
if growflag {
|
|
// force a hashtable resize
|
|
for i := 0; i < 100; i++ {
|
|
m[FloatInt{3.0, i}] = 0
|
|
}
|
|
// then change all the entries
|
|
// to negative zero
|
|
m[FloatInt{negzero, 0}] = 1 | 16
|
|
m[FloatInt{negzero, 1}] = 2 | 16
|
|
m[FloatInt{negzero, 2}] = 4 | 16
|
|
m[FloatInt{negzero, 3}] = 8 | 16
|
|
growflag = false
|
|
}
|
|
}
|
|
if s != 15 {
|
|
t.Error("entry missing", s)
|
|
}
|
|
if cnt != 4 {
|
|
t.Error("wrong number of entries returned by iterator", cnt)
|
|
}
|
|
if negcnt != 3 {
|
|
t.Error("update to negzero missed by iteration", negcnt)
|
|
}
|
|
}
|
|
|
|
func TestIterGrowAndDelete(t *testing.T) {
|
|
m := make(map[int]int, 4)
|
|
for i := 0; i < 100; i++ {
|
|
m[i] = i
|
|
}
|
|
growflag := true
|
|
for k := range m {
|
|
if growflag {
|
|
// grow the table
|
|
for i := 100; i < 1000; i++ {
|
|
m[i] = i
|
|
}
|
|
// delete all odd keys
|
|
for i := 1; i < 1000; i += 2 {
|
|
delete(m, i)
|
|
}
|
|
growflag = false
|
|
} else {
|
|
if k&1 == 1 {
|
|
t.Error("odd value returned")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// make sure old bucket arrays don't get GCd while
|
|
// an iterator is still using them.
|
|
func TestIterGrowWithGC(t *testing.T) {
|
|
m := make(map[int]int, 4)
|
|
for i := 0; i < 8; i++ {
|
|
m[i] = i
|
|
}
|
|
for i := 8; i < 16; i++ {
|
|
m[i] += i
|
|
}
|
|
growflag := true
|
|
bitmask := 0
|
|
for k := range m {
|
|
if k < 16 {
|
|
bitmask |= 1 << uint(k)
|
|
}
|
|
if growflag {
|
|
// grow the table
|
|
for i := 100; i < 1000; i++ {
|
|
m[i] = i
|
|
}
|
|
// trigger a gc
|
|
runtime.GC()
|
|
growflag = false
|
|
}
|
|
}
|
|
if bitmask != 1<<16-1 {
|
|
t.Error("missing key", bitmask)
|
|
}
|
|
}
|
|
|
|
func testConcurrentReadsAfterGrowth(t *testing.T, useReflect bool) {
|
|
t.Parallel()
|
|
if runtime.GOMAXPROCS(-1) == 1 {
|
|
if runtime.GOARCH == "s390" {
|
|
// Test uses too much address space on 31-bit S390.
|
|
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(8))
|
|
} else {
|
|
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(16))
|
|
}
|
|
}
|
|
numLoop := 10
|
|
numGrowStep := 250
|
|
numReader := 16
|
|
if testing.Short() {
|
|
numLoop, numGrowStep = 2, 100
|
|
}
|
|
for i := 0; i < numLoop; i++ {
|
|
m := make(map[int]int, 0)
|
|
for gs := 0; gs < numGrowStep; gs++ {
|
|
m[gs] = gs
|
|
var wg sync.WaitGroup
|
|
wg.Add(numReader * 2)
|
|
for nr := 0; nr < numReader; nr++ {
|
|
go func() {
|
|
defer wg.Done()
|
|
for range m {
|
|
}
|
|
}()
|
|
go func() {
|
|
defer wg.Done()
|
|
for key := 0; key < gs; key++ {
|
|
_ = m[key]
|
|
}
|
|
}()
|
|
if useReflect {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
mv := reflect.ValueOf(m)
|
|
keys := mv.MapKeys()
|
|
for _, k := range keys {
|
|
mv.MapIndex(k)
|
|
}
|
|
}()
|
|
}
|
|
}
|
|
wg.Wait()
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestConcurrentReadsAfterGrowth(t *testing.T) {
|
|
testConcurrentReadsAfterGrowth(t, false)
|
|
}
|
|
|
|
func TestConcurrentReadsAfterGrowthReflect(t *testing.T) {
|
|
testConcurrentReadsAfterGrowth(t, true)
|
|
}
|
|
|
|
func TestBigItems(t *testing.T) {
|
|
var key [256]string
|
|
for i := 0; i < 256; i++ {
|
|
key[i] = "foo"
|
|
}
|
|
m := make(map[[256]string][256]string, 4)
|
|
for i := 0; i < 100; i++ {
|
|
key[37] = fmt.Sprintf("string%02d", i)
|
|
m[key] = key
|
|
}
|
|
var keys [100]string
|
|
var values [100]string
|
|
i := 0
|
|
for k, v := range m {
|
|
keys[i] = k[37]
|
|
values[i] = v[37]
|
|
i++
|
|
}
|
|
sort.Strings(keys[:])
|
|
sort.Strings(values[:])
|
|
for i := 0; i < 100; i++ {
|
|
if keys[i] != fmt.Sprintf("string%02d", i) {
|
|
t.Errorf("#%d: missing key: %v", i, keys[i])
|
|
}
|
|
if values[i] != fmt.Sprintf("string%02d", i) {
|
|
t.Errorf("#%d: missing value: %v", i, values[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMapHugeZero(t *testing.T) {
|
|
type T [4000]byte
|
|
m := map[int]T{}
|
|
x := m[0]
|
|
if x != (T{}) {
|
|
t.Errorf("map value not zero")
|
|
}
|
|
y, ok := m[0]
|
|
if ok {
|
|
t.Errorf("map value should be missing")
|
|
}
|
|
if y != (T{}) {
|
|
t.Errorf("map value not zero")
|
|
}
|
|
}
|
|
|
|
type empty struct {
|
|
}
|
|
|
|
func TestEmptyKeyAndValue(t *testing.T) {
|
|
a := make(map[int]empty, 4)
|
|
b := make(map[empty]int, 4)
|
|
c := make(map[empty]empty, 4)
|
|
a[0] = empty{}
|
|
b[empty{}] = 0
|
|
b[empty{}] = 1
|
|
c[empty{}] = empty{}
|
|
|
|
if len(a) != 1 {
|
|
t.Errorf("empty value insert problem")
|
|
}
|
|
if b[empty{}] != 1 {
|
|
t.Errorf("empty key returned wrong value")
|
|
}
|
|
}
|
|
|
|
// Tests a map with a single bucket, with same-lengthed short keys
|
|
// ("quick keys") as well as long keys.
|
|
func TestSingleBucketMapStringKeys_DupLen(t *testing.T) {
|
|
testMapLookups(t, map[string]string{
|
|
"x": "x1val",
|
|
"xx": "x2val",
|
|
"foo": "fooval",
|
|
"bar": "barval", // same key length as "foo"
|
|
"xxxx": "x4val",
|
|
strings.Repeat("x", 128): "longval1",
|
|
strings.Repeat("y", 128): "longval2",
|
|
})
|
|
}
|
|
|
|
// Tests a map with a single bucket, with all keys having different lengths.
|
|
func TestSingleBucketMapStringKeys_NoDupLen(t *testing.T) {
|
|
testMapLookups(t, map[string]string{
|
|
"x": "x1val",
|
|
"xx": "x2val",
|
|
"foo": "fooval",
|
|
"xxxx": "x4val",
|
|
"xxxxx": "x5val",
|
|
"xxxxxx": "x6val",
|
|
strings.Repeat("x", 128): "longval",
|
|
})
|
|
}
|
|
|
|
func testMapLookups(t *testing.T, m map[string]string) {
|
|
for k, v := range m {
|
|
if m[k] != v {
|
|
t.Fatalf("m[%q] = %q; want %q", k, m[k], v)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Tests whether the iterator returns the right elements when
|
|
// started in the middle of a grow, when the keys are NaNs.
|
|
func TestMapNanGrowIterator(t *testing.T) {
|
|
m := make(map[float64]int)
|
|
nan := math.NaN()
|
|
const nBuckets = 16
|
|
// To fill nBuckets buckets takes LOAD * nBuckets keys.
|
|
nKeys := int(nBuckets * *runtime.HashLoad)
|
|
|
|
// Get map to full point with nan keys.
|
|
for i := 0; i < nKeys; i++ {
|
|
m[nan] = i
|
|
}
|
|
// Trigger grow
|
|
m[1.0] = 1
|
|
delete(m, 1.0)
|
|
|
|
// Run iterator
|
|
found := make(map[int]struct{})
|
|
for _, v := range m {
|
|
if v != -1 {
|
|
if _, repeat := found[v]; repeat {
|
|
t.Fatalf("repeat of value %d", v)
|
|
}
|
|
found[v] = struct{}{}
|
|
}
|
|
if len(found) == nKeys/2 {
|
|
// Halfway through iteration, finish grow.
|
|
for i := 0; i < nBuckets; i++ {
|
|
delete(m, 1.0)
|
|
}
|
|
}
|
|
}
|
|
if len(found) != nKeys {
|
|
t.Fatalf("missing value")
|
|
}
|
|
}
|
|
|
|
func TestMapIterOrder(t *testing.T) {
|
|
for _, n := range [...]int{3, 7, 9, 15} {
|
|
for i := 0; i < 1000; i++ {
|
|
// Make m be {0: true, 1: true, ..., n-1: true}.
|
|
m := make(map[int]bool)
|
|
for i := 0; i < n; i++ {
|
|
m[i] = true
|
|
}
|
|
// Check that iterating over the map produces at least two different orderings.
|
|
ord := func() []int {
|
|
var s []int
|
|
for key := range m {
|
|
s = append(s, key)
|
|
}
|
|
return s
|
|
}
|
|
first := ord()
|
|
ok := false
|
|
for try := 0; try < 100; try++ {
|
|
if !reflect.DeepEqual(first, ord()) {
|
|
ok = true
|
|
break
|
|
}
|
|
}
|
|
if !ok {
|
|
t.Errorf("Map with n=%d elements had consistent iteration order: %v", n, first)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Issue 8410
|
|
func TestMapSparseIterOrder(t *testing.T) {
|
|
// Run several rounds to increase the probability
|
|
// of failure. One is not enough.
|
|
NextRound:
|
|
for round := 0; round < 10; round++ {
|
|
m := make(map[int]bool)
|
|
// Add 1000 items, remove 980.
|
|
for i := 0; i < 1000; i++ {
|
|
m[i] = true
|
|
}
|
|
for i := 20; i < 1000; i++ {
|
|
delete(m, i)
|
|
}
|
|
|
|
var first []int
|
|
for i := range m {
|
|
first = append(first, i)
|
|
}
|
|
|
|
// 800 chances to get a different iteration order.
|
|
// See bug 8736 for why we need so many tries.
|
|
for n := 0; n < 800; n++ {
|
|
idx := 0
|
|
for i := range m {
|
|
if i != first[idx] {
|
|
// iteration order changed.
|
|
continue NextRound
|
|
}
|
|
idx++
|
|
}
|
|
}
|
|
t.Fatalf("constant iteration order on round %d: %v", round, first)
|
|
}
|
|
}
|
|
|
|
func TestMapStringBytesLookup(t *testing.T) {
|
|
// Use large string keys to avoid small-allocation coalescing,
|
|
// which can cause AllocsPerRun to report lower counts than it should.
|
|
m := map[string]int{
|
|
"1000000000000000000000000000000000000000000000000": 1,
|
|
"2000000000000000000000000000000000000000000000000": 2,
|
|
}
|
|
buf := []byte("1000000000000000000000000000000000000000000000000")
|
|
if x := m[string(buf)]; x != 1 {
|
|
t.Errorf(`m[string([]byte("1"))] = %d, want 1`, x)
|
|
}
|
|
buf[0] = '2'
|
|
if x := m[string(buf)]; x != 2 {
|
|
t.Errorf(`m[string([]byte("2"))] = %d, want 2`, x)
|
|
}
|
|
|
|
t.Skip("does not work on gccgo without better escape analysis")
|
|
|
|
var x int
|
|
n := testing.AllocsPerRun(100, func() {
|
|
x += m[string(buf)]
|
|
})
|
|
if n != 0 {
|
|
t.Errorf("AllocsPerRun for m[string(buf)] = %v, want 0", n)
|
|
}
|
|
|
|
x = 0
|
|
n = testing.AllocsPerRun(100, func() {
|
|
y, ok := m[string(buf)]
|
|
if !ok {
|
|
panic("!ok")
|
|
}
|
|
x += y
|
|
})
|
|
if n != 0 {
|
|
t.Errorf("AllocsPerRun for x,ok = m[string(buf)] = %v, want 0", n)
|
|
}
|
|
}
|
|
|
|
func TestMapLargeKeyNoPointer(t *testing.T) {
|
|
const (
|
|
I = 1000
|
|
N = 64
|
|
)
|
|
type T [N]int
|
|
m := make(map[T]int)
|
|
for i := 0; i < I; i++ {
|
|
var v T
|
|
for j := 0; j < N; j++ {
|
|
v[j] = i + j
|
|
}
|
|
m[v] = i
|
|
}
|
|
runtime.GC()
|
|
for i := 0; i < I; i++ {
|
|
var v T
|
|
for j := 0; j < N; j++ {
|
|
v[j] = i + j
|
|
}
|
|
if m[v] != i {
|
|
t.Fatalf("corrupted map: want %+v, got %+v", i, m[v])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMapLargeValNoPointer(t *testing.T) {
|
|
const (
|
|
I = 1000
|
|
N = 64
|
|
)
|
|
type T [N]int
|
|
m := make(map[int]T)
|
|
for i := 0; i < I; i++ {
|
|
var v T
|
|
for j := 0; j < N; j++ {
|
|
v[j] = i + j
|
|
}
|
|
m[i] = v
|
|
}
|
|
runtime.GC()
|
|
for i := 0; i < I; i++ {
|
|
var v T
|
|
for j := 0; j < N; j++ {
|
|
v[j] = i + j
|
|
}
|
|
v1 := m[i]
|
|
for j := 0; j < N; j++ {
|
|
if v1[j] != v[j] {
|
|
t.Fatalf("corrupted map: want %+v, got %+v", v, v1)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test that making a map with a large or invalid hint
|
|
// doesn't panic. (Issue 19926).
|
|
func TestIgnoreBogusMapHint(t *testing.T) {
|
|
for _, hint := range []int64{-1, 1 << 62} {
|
|
_ = make(map[int]int, hint)
|
|
}
|
|
}
|
|
|
|
var mapSink map[int]int
|
|
|
|
var mapBucketTests = [...]struct {
|
|
n int // n is the number of map elements
|
|
noescape int // number of expected buckets for non-escaping map
|
|
escape int // number of expected buckets for escaping map
|
|
}{
|
|
{-(1 << 30), 1, 1},
|
|
{-1, 1, 1},
|
|
{0, 1, 1},
|
|
{1, 1, 1},
|
|
{8, 1, 1},
|
|
{9, 2, 2},
|
|
{13, 2, 2},
|
|
{14, 4, 4},
|
|
{26, 4, 4},
|
|
}
|
|
|
|
func TestMapBuckets(t *testing.T) {
|
|
// Test that maps of different sizes have the right number of buckets.
|
|
// Non-escaping maps with small buckets (like map[int]int) never
|
|
// have a nil bucket pointer due to starting with preallocated buckets
|
|
// on the stack. Escaping maps start with a non-nil bucket pointer if
|
|
// hint size is above bucketCnt and thereby have more than one bucket.
|
|
// These tests depend on bucketCnt and loadFactor* in map.go.
|
|
t.Run("mapliteral", func(t *testing.T) {
|
|
for _, tt := range mapBucketTests {
|
|
localMap := map[int]int{}
|
|
// Skip test on gccgo until escape analysis is
|
|
// turned on.
|
|
if runtime.MapBucketsPointerIsNil(localMap) && runtime.Compiler != "gccgo" {
|
|
t.Errorf("no escape: buckets pointer is nil for non-escaping map")
|
|
}
|
|
for i := 0; i < tt.n; i++ {
|
|
localMap[i] = i
|
|
}
|
|
if got := runtime.MapBucketsCount(localMap); got != tt.noescape {
|
|
t.Errorf("no escape: n=%d want %d buckets, got %d", tt.n, tt.noescape, got)
|
|
}
|
|
escapingMap := map[int]int{}
|
|
if count := runtime.MapBucketsCount(escapingMap); count > 1 && runtime.MapBucketsPointerIsNil(escapingMap) {
|
|
t.Errorf("escape: buckets pointer is nil for n=%d buckets", count)
|
|
}
|
|
for i := 0; i < tt.n; i++ {
|
|
escapingMap[i] = i
|
|
}
|
|
if got := runtime.MapBucketsCount(escapingMap); got != tt.escape {
|
|
t.Errorf("escape n=%d want %d buckets, got %d", tt.n, tt.escape, got)
|
|
}
|
|
mapSink = escapingMap
|
|
}
|
|
})
|
|
t.Run("nohint", func(t *testing.T) {
|
|
for _, tt := range mapBucketTests {
|
|
localMap := make(map[int]int)
|
|
// Skip test on gccgo until escape analysis is
|
|
// turned on.
|
|
if runtime.MapBucketsPointerIsNil(localMap) && runtime.Compiler != "gccgo" {
|
|
t.Errorf("no escape: buckets pointer is nil for non-escaping map")
|
|
}
|
|
for i := 0; i < tt.n; i++ {
|
|
localMap[i] = i
|
|
}
|
|
if got := runtime.MapBucketsCount(localMap); got != tt.noescape {
|
|
t.Errorf("no escape: n=%d want %d buckets, got %d", tt.n, tt.noescape, got)
|
|
}
|
|
escapingMap := make(map[int]int)
|
|
if count := runtime.MapBucketsCount(escapingMap); count > 1 && runtime.MapBucketsPointerIsNil(escapingMap) {
|
|
t.Errorf("escape: buckets pointer is nil for n=%d buckets", count)
|
|
}
|
|
for i := 0; i < tt.n; i++ {
|
|
escapingMap[i] = i
|
|
}
|
|
if got := runtime.MapBucketsCount(escapingMap); got != tt.escape {
|
|
t.Errorf("escape: n=%d want %d buckets, got %d", tt.n, tt.escape, got)
|
|
}
|
|
mapSink = escapingMap
|
|
}
|
|
})
|
|
t.Run("makemap", func(t *testing.T) {
|
|
for _, tt := range mapBucketTests {
|
|
localMap := make(map[int]int, tt.n)
|
|
// Skip test on gccgo until escape analysis is
|
|
// turned on.
|
|
if runtime.MapBucketsPointerIsNil(localMap) && runtime.Compiler != "gccgo" {
|
|
t.Errorf("no escape: buckets pointer is nil for non-escaping map")
|
|
}
|
|
for i := 0; i < tt.n; i++ {
|
|
localMap[i] = i
|
|
}
|
|
if got := runtime.MapBucketsCount(localMap); got != tt.noescape {
|
|
t.Errorf("no escape: n=%d want %d buckets, got %d", tt.n, tt.noescape, got)
|
|
}
|
|
escapingMap := make(map[int]int, tt.n)
|
|
if count := runtime.MapBucketsCount(escapingMap); count > 1 && runtime.MapBucketsPointerIsNil(escapingMap) {
|
|
t.Errorf("escape: buckets pointer is nil for n=%d buckets", count)
|
|
}
|
|
for i := 0; i < tt.n; i++ {
|
|
escapingMap[i] = i
|
|
}
|
|
if got := runtime.MapBucketsCount(escapingMap); got != tt.escape {
|
|
t.Errorf("escape: n=%d want %d buckets, got %d", tt.n, tt.escape, got)
|
|
}
|
|
mapSink = escapingMap
|
|
}
|
|
})
|
|
t.Run("makemap64", func(t *testing.T) {
|
|
for _, tt := range mapBucketTests {
|
|
localMap := make(map[int]int, int64(tt.n))
|
|
// Skip test on gccgo until escape analysis is
|
|
// turned on.
|
|
if runtime.MapBucketsPointerIsNil(localMap) && runtime.Compiler != "gccgo" {
|
|
t.Errorf("no escape: buckets pointer is nil for non-escaping map")
|
|
}
|
|
for i := 0; i < tt.n; i++ {
|
|
localMap[i] = i
|
|
}
|
|
if got := runtime.MapBucketsCount(localMap); got != tt.noescape {
|
|
t.Errorf("no escape: n=%d want %d buckets, got %d", tt.n, tt.noescape, got)
|
|
}
|
|
escapingMap := make(map[int]int, tt.n)
|
|
if count := runtime.MapBucketsCount(escapingMap); count > 1 && runtime.MapBucketsPointerIsNil(escapingMap) {
|
|
t.Errorf("escape: buckets pointer is nil for n=%d buckets", count)
|
|
}
|
|
for i := 0; i < tt.n; i++ {
|
|
escapingMap[i] = i
|
|
}
|
|
if got := runtime.MapBucketsCount(escapingMap); got != tt.escape {
|
|
t.Errorf("escape: n=%d want %d buckets, got %d", tt.n, tt.escape, got)
|
|
}
|
|
mapSink = escapingMap
|
|
}
|
|
})
|
|
|
|
}
|
|
|
|
func benchmarkMapPop(b *testing.B, n int) {
|
|
m := map[int]int{}
|
|
for i := 0; i < b.N; i++ {
|
|
for j := 0; j < n; j++ {
|
|
m[j] = j
|
|
}
|
|
for j := 0; j < n; j++ {
|
|
// Use iterator to pop an element.
|
|
// We want this to be fast, see issue 8412.
|
|
for k := range m {
|
|
delete(m, k)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkMapPop100(b *testing.B) { benchmarkMapPop(b, 100) }
|
|
func BenchmarkMapPop1000(b *testing.B) { benchmarkMapPop(b, 1000) }
|
|
func BenchmarkMapPop10000(b *testing.B) { benchmarkMapPop(b, 10000) }
|
|
|
|
var testNonEscapingMapVariable int = 8
|
|
|
|
func TestNonEscapingMap(t *testing.T) {
|
|
t.Skip("does not work on gccgo without better escape analysis")
|
|
n := testing.AllocsPerRun(1000, func() {
|
|
m := map[int]int{}
|
|
m[0] = 0
|
|
})
|
|
if n != 0 {
|
|
t.Fatalf("mapliteral: want 0 allocs, got %v", n)
|
|
}
|
|
n = testing.AllocsPerRun(1000, func() {
|
|
m := make(map[int]int)
|
|
m[0] = 0
|
|
})
|
|
if n != 0 {
|
|
t.Fatalf("no hint: want 0 allocs, got %v", n)
|
|
}
|
|
n = testing.AllocsPerRun(1000, func() {
|
|
m := make(map[int]int, 8)
|
|
m[0] = 0
|
|
})
|
|
if n != 0 {
|
|
t.Fatalf("with small hint: want 0 allocs, got %v", n)
|
|
}
|
|
n = testing.AllocsPerRun(1000, func() {
|
|
m := make(map[int]int, testNonEscapingMapVariable)
|
|
m[0] = 0
|
|
})
|
|
if n != 0 {
|
|
t.Fatalf("with variable hint: want 0 allocs, got %v", n)
|
|
}
|
|
|
|
}
|
|
|
|
func benchmarkMapAssignInt32(b *testing.B, n int) {
|
|
a := make(map[int32]int)
|
|
for i := 0; i < b.N; i++ {
|
|
a[int32(i&(n-1))] = i
|
|
}
|
|
}
|
|
|
|
func benchmarkMapOperatorAssignInt32(b *testing.B, n int) {
|
|
a := make(map[int32]int)
|
|
for i := 0; i < b.N; i++ {
|
|
a[int32(i&(n-1))] += i
|
|
}
|
|
}
|
|
|
|
func benchmarkMapAppendAssignInt32(b *testing.B, n int) {
|
|
a := make(map[int32][]int)
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
key := int32(i & (n - 1))
|
|
a[key] = append(a[key], i)
|
|
}
|
|
}
|
|
|
|
func benchmarkMapDeleteInt32(b *testing.B, n int) {
|
|
a := make(map[int32]int, n)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
if len(a) == 0 {
|
|
b.StopTimer()
|
|
for j := i; j < i+n; j++ {
|
|
a[int32(j)] = j
|
|
}
|
|
b.StartTimer()
|
|
}
|
|
delete(a, int32(i))
|
|
}
|
|
}
|
|
|
|
func benchmarkMapAssignInt64(b *testing.B, n int) {
|
|
a := make(map[int64]int)
|
|
for i := 0; i < b.N; i++ {
|
|
a[int64(i&(n-1))] = i
|
|
}
|
|
}
|
|
|
|
func benchmarkMapOperatorAssignInt64(b *testing.B, n int) {
|
|
a := make(map[int64]int)
|
|
for i := 0; i < b.N; i++ {
|
|
a[int64(i&(n-1))] += i
|
|
}
|
|
}
|
|
|
|
func benchmarkMapAppendAssignInt64(b *testing.B, n int) {
|
|
a := make(map[int64][]int)
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
key := int64(i & (n - 1))
|
|
a[key] = append(a[key], i)
|
|
}
|
|
}
|
|
|
|
func benchmarkMapDeleteInt64(b *testing.B, n int) {
|
|
a := make(map[int64]int, n)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
if len(a) == 0 {
|
|
b.StopTimer()
|
|
for j := i; j < i+n; j++ {
|
|
a[int64(j)] = j
|
|
}
|
|
b.StartTimer()
|
|
}
|
|
delete(a, int64(i))
|
|
}
|
|
}
|
|
|
|
func benchmarkMapAssignStr(b *testing.B, n int) {
|
|
k := make([]string, n)
|
|
for i := 0; i < len(k); i++ {
|
|
k[i] = strconv.Itoa(i)
|
|
}
|
|
b.ResetTimer()
|
|
a := make(map[string]int)
|
|
for i := 0; i < b.N; i++ {
|
|
a[k[i&(n-1)]] = i
|
|
}
|
|
}
|
|
|
|
func benchmarkMapOperatorAssignStr(b *testing.B, n int) {
|
|
k := make([]string, n)
|
|
for i := 0; i < len(k); i++ {
|
|
k[i] = strconv.Itoa(i)
|
|
}
|
|
b.ResetTimer()
|
|
a := make(map[string]string)
|
|
for i := 0; i < b.N; i++ {
|
|
key := k[i&(n-1)]
|
|
a[key] += key
|
|
}
|
|
}
|
|
|
|
func benchmarkMapAppendAssignStr(b *testing.B, n int) {
|
|
k := make([]string, n)
|
|
for i := 0; i < len(k); i++ {
|
|
k[i] = strconv.Itoa(i)
|
|
}
|
|
a := make(map[string][]string)
|
|
b.ReportAllocs()
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
key := k[i&(n-1)]
|
|
a[key] = append(a[key], key)
|
|
}
|
|
}
|
|
|
|
func benchmarkMapDeleteStr(b *testing.B, n int) {
|
|
i2s := make([]string, n)
|
|
for i := 0; i < n; i++ {
|
|
i2s[i] = strconv.Itoa(i)
|
|
}
|
|
a := make(map[string]int, n)
|
|
b.ResetTimer()
|
|
k := 0
|
|
for i := 0; i < b.N; i++ {
|
|
if len(a) == 0 {
|
|
b.StopTimer()
|
|
for j := 0; j < n; j++ {
|
|
a[i2s[j]] = j
|
|
}
|
|
k = i
|
|
b.StartTimer()
|
|
}
|
|
delete(a, i2s[i-k])
|
|
}
|
|
}
|
|
|
|
func runWith(f func(*testing.B, int), v ...int) func(*testing.B) {
|
|
return func(b *testing.B) {
|
|
for _, n := range v {
|
|
b.Run(strconv.Itoa(n), func(b *testing.B) { f(b, n) })
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkMapAssign(b *testing.B) {
|
|
b.Run("Int32", runWith(benchmarkMapAssignInt32, 1<<8, 1<<16))
|
|
b.Run("Int64", runWith(benchmarkMapAssignInt64, 1<<8, 1<<16))
|
|
b.Run("Str", runWith(benchmarkMapAssignStr, 1<<8, 1<<16))
|
|
}
|
|
|
|
func BenchmarkMapOperatorAssign(b *testing.B) {
|
|
b.Run("Int32", runWith(benchmarkMapOperatorAssignInt32, 1<<8, 1<<16))
|
|
b.Run("Int64", runWith(benchmarkMapOperatorAssignInt64, 1<<8, 1<<16))
|
|
b.Run("Str", runWith(benchmarkMapOperatorAssignStr, 1<<8, 1<<16))
|
|
}
|
|
|
|
func BenchmarkMapAppendAssign(b *testing.B) {
|
|
b.Run("Int32", runWith(benchmarkMapAppendAssignInt32, 1<<8, 1<<16))
|
|
b.Run("Int64", runWith(benchmarkMapAppendAssignInt64, 1<<8, 1<<16))
|
|
b.Run("Str", runWith(benchmarkMapAppendAssignStr, 1<<8, 1<<16))
|
|
}
|
|
|
|
func BenchmarkMapDelete(b *testing.B) {
|
|
b.Run("Int32", runWith(benchmarkMapDeleteInt32, 100, 1000, 10000))
|
|
b.Run("Int64", runWith(benchmarkMapDeleteInt64, 100, 1000, 10000))
|
|
b.Run("Str", runWith(benchmarkMapDeleteStr, 100, 1000, 10000))
|
|
}
|
|
|
|
func TestDeferDeleteSlow(t *testing.T) {
|
|
ks := []complex128{0, 1, 2, 3}
|
|
|
|
m := make(map[interface{}]int)
|
|
for i, k := range ks {
|
|
m[k] = i
|
|
}
|
|
if len(m) != len(ks) {
|
|
t.Errorf("want %d elements, got %d", len(ks), len(m))
|
|
}
|
|
|
|
func() {
|
|
for _, k := range ks {
|
|
defer delete(m, k)
|
|
}
|
|
}()
|
|
if len(m) != 0 {
|
|
t.Errorf("want 0 elements, got %d", len(m))
|
|
}
|
|
}
|
|
|
|
// TestIncrementAfterDeleteValueInt and other test Issue 25936.
|
|
// Value types int, int32, int64 are affected. Value type string
|
|
// works as expected.
|
|
func TestIncrementAfterDeleteValueInt(t *testing.T) {
|
|
const key1 = 12
|
|
const key2 = 13
|
|
|
|
m := make(map[int]int)
|
|
m[key1] = 99
|
|
delete(m, key1)
|
|
m[key2]++
|
|
if n2 := m[key2]; n2 != 1 {
|
|
t.Errorf("incremented 0 to %d", n2)
|
|
}
|
|
}
|
|
|
|
func TestIncrementAfterDeleteValueInt32(t *testing.T) {
|
|
const key1 = 12
|
|
const key2 = 13
|
|
|
|
m := make(map[int]int32)
|
|
m[key1] = 99
|
|
delete(m, key1)
|
|
m[key2]++
|
|
if n2 := m[key2]; n2 != 1 {
|
|
t.Errorf("incremented 0 to %d", n2)
|
|
}
|
|
}
|
|
|
|
func TestIncrementAfterDeleteValueInt64(t *testing.T) {
|
|
const key1 = 12
|
|
const key2 = 13
|
|
|
|
m := make(map[int]int64)
|
|
m[key1] = 99
|
|
delete(m, key1)
|
|
m[key2]++
|
|
if n2 := m[key2]; n2 != 1 {
|
|
t.Errorf("incremented 0 to %d", n2)
|
|
}
|
|
}
|
|
|
|
func TestIncrementAfterDeleteKeyStringValueInt(t *testing.T) {
|
|
const key1 = ""
|
|
const key2 = "x"
|
|
|
|
m := make(map[string]int)
|
|
m[key1] = 99
|
|
delete(m, key1)
|
|
m[key2] += 1
|
|
if n2 := m[key2]; n2 != 1 {
|
|
t.Errorf("incremented 0 to %d", n2)
|
|
}
|
|
}
|
|
|
|
func TestIncrementAfterDeleteKeyValueString(t *testing.T) {
|
|
const key1 = ""
|
|
const key2 = "x"
|
|
|
|
m := make(map[string]string)
|
|
m[key1] = "99"
|
|
delete(m, key1)
|
|
m[key2] += "1"
|
|
if n2 := m[key2]; n2 != "1" {
|
|
t.Errorf("appended '1' to empty (nil) string, got %s", n2)
|
|
}
|
|
}
|
|
|
|
// TestIncrementAfterBulkClearKeyStringValueInt tests that map bulk
|
|
// deletion (mapclear) still works as expected. Note that it was not
|
|
// affected by Issue 25936.
|
|
func TestIncrementAfterBulkClearKeyStringValueInt(t *testing.T) {
|
|
const key1 = ""
|
|
const key2 = "x"
|
|
|
|
m := make(map[string]int)
|
|
m[key1] = 99
|
|
for k := range m {
|
|
delete(m, k)
|
|
}
|
|
m[key2]++
|
|
if n2 := m[key2]; n2 != 1 {
|
|
t.Errorf("incremented 0 to %d", n2)
|
|
}
|
|
}
|
|
|
|
func TestMapTombstones(t *testing.T) {
|
|
m := map[int]int{}
|
|
const N = 10000
|
|
// Fill a map.
|
|
for i := 0; i < N; i++ {
|
|
m[i] = i
|
|
}
|
|
runtime.MapTombstoneCheck(m)
|
|
// Delete half of the entries.
|
|
for i := 0; i < N; i += 2 {
|
|
delete(m, i)
|
|
}
|
|
runtime.MapTombstoneCheck(m)
|
|
// Add new entries to fill in holes.
|
|
for i := N; i < 3*N/2; i++ {
|
|
m[i] = i
|
|
}
|
|
runtime.MapTombstoneCheck(m)
|
|
// Delete everything.
|
|
for i := 0; i < 3*N/2; i++ {
|
|
delete(m, i)
|
|
}
|
|
runtime.MapTombstoneCheck(m)
|
|
}
|
|
|
|
type canString int
|
|
|
|
func (c canString) String() string {
|
|
return fmt.Sprintf("%d", int(c))
|
|
}
|
|
|
|
func TestMapInterfaceKey(t *testing.T) {
|
|
// Test all the special cases in runtime.typehash.
|
|
type GrabBag struct {
|
|
f32 float32
|
|
f64 float64
|
|
c64 complex64
|
|
c128 complex128
|
|
s string
|
|
i0 interface{}
|
|
i1 interface {
|
|
String() string
|
|
}
|
|
a [4]string
|
|
}
|
|
|
|
m := map[interface{}]bool{}
|
|
// Put a bunch of data in m, so that a bad hash is likely to
|
|
// lead to a bad bucket, which will lead to a missed lookup.
|
|
for i := 0; i < 1000; i++ {
|
|
m[i] = true
|
|
}
|
|
m[GrabBag{f32: 1.0}] = true
|
|
if !m[GrabBag{f32: 1.0}] {
|
|
panic("f32 not found")
|
|
}
|
|
m[GrabBag{f64: 1.0}] = true
|
|
if !m[GrabBag{f64: 1.0}] {
|
|
panic("f64 not found")
|
|
}
|
|
m[GrabBag{c64: 1.0i}] = true
|
|
if !m[GrabBag{c64: 1.0i}] {
|
|
panic("c64 not found")
|
|
}
|
|
m[GrabBag{c128: 1.0i}] = true
|
|
if !m[GrabBag{c128: 1.0i}] {
|
|
panic("c128 not found")
|
|
}
|
|
m[GrabBag{s: "foo"}] = true
|
|
if !m[GrabBag{s: "foo"}] {
|
|
panic("string not found")
|
|
}
|
|
m[GrabBag{i0: "foo"}] = true
|
|
if !m[GrabBag{i0: "foo"}] {
|
|
panic("interface{} not found")
|
|
}
|
|
m[GrabBag{i1: canString(5)}] = true
|
|
if !m[GrabBag{i1: canString(5)}] {
|
|
panic("interface{String() string} not found")
|
|
}
|
|
m[GrabBag{a: [4]string{"foo", "bar", "baz", "bop"}}] = true
|
|
if !m[GrabBag{a: [4]string{"foo", "bar", "baz", "bop"}}] {
|
|
panic("array not found")
|
|
}
|
|
}
|