Imported Upstream version 1.4upstream/1.4

1 files changed, 0 insertions, 300 deletions

diff --git a/src/pkg/runtime/mapspeed_test.go b/src/pkg/runtime/mapspeed_test.go
deleted file mode 100644
index da45ea11e..000000000
--- a/src/pkg/runtime/mapspeed_test.go
+++ /dev/null
@@ -1,300 +0,0 @@
-// 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"
-	"strings"
-	"testing"
-)
-
-const size = 10
-
-func BenchmarkHashStringSpeed(b *testing.B) {
-	strings := make([]string, size)
-	for i := 0; i < size; i++ {
-		strings[i] = fmt.Sprintf("string#%d", i)
-	}
-	sum := 0
-	m := make(map[string]int, size)
-	for i := 0; i < size; i++ {
-		m[strings[i]] = 0
-	}
-	idx := 0
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		sum += m[strings[idx]]
-		idx++
-		if idx == size {
-			idx = 0
-		}
-	}
-}
-
-type chunk [17]byte
-
-func BenchmarkHashBytesSpeed(b *testing.B) {
-	// a bunch of chunks, each with a different alignment mod 16
-	var chunks [size]chunk
-	// initialize each to a different value
-	for i := 0; i < size; i++ {
-		chunks[i][0] = byte(i)
-	}
-	// put into a map
-	m := make(map[chunk]int, size)
-	for i, c := range chunks {
-		m[c] = i
-	}
-	idx := 0
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		if m[chunks[idx]] != idx {
-			b.Error("bad map entry for chunk")
-		}
-		idx++
-		if idx == size {
-			idx = 0
-		}
-	}
-}
-
-func BenchmarkHashInt32Speed(b *testing.B) {
-	ints := make([]int32, size)
-	for i := 0; i < size; i++ {
-		ints[i] = int32(i)
-	}
-	sum := 0
-	m := make(map[int32]int, size)
-	for i := 0; i < size; i++ {
-		m[ints[i]] = 0
-	}
-	idx := 0
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		sum += m[ints[idx]]
-		idx++
-		if idx == size {
-			idx = 0
-		}
-	}
-}
-
-func BenchmarkHashInt64Speed(b *testing.B) {
-	ints := make([]int64, size)
-	for i := 0; i < size; i++ {
-		ints[i] = int64(i)
-	}
-	sum := 0
-	m := make(map[int64]int, size)
-	for i := 0; i < size; i++ {
-		m[ints[i]] = 0
-	}
-	idx := 0
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		sum += m[ints[idx]]
-		idx++
-		if idx == size {
-			idx = 0
-		}
-	}
-}
-func BenchmarkHashStringArraySpeed(b *testing.B) {
-	stringpairs := make([][2]string, size)
-	for i := 0; i < size; i++ {
-		for j := 0; j < 2; j++ {
-			stringpairs[i][j] = fmt.Sprintf("string#%d/%d", i, j)
-		}
-	}
-	sum := 0
-	m := make(map[[2]string]int, size)
-	for i := 0; i < size; i++ {
-		m[stringpairs[i]] = 0
-	}
-	idx := 0
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		sum += m[stringpairs[idx]]
-		idx++
-		if idx == size {
-			idx = 0
-		}
-	}
-}
-
-func BenchmarkMegMap(b *testing.B) {
-	m := make(map[string]bool)
-	for suffix := 'A'; suffix <= 'G'; suffix++ {
-		m[strings.Repeat("X", 1<<20-1)+fmt.Sprint(suffix)] = true
-	}
-	key := strings.Repeat("X", 1<<20-1) + "k"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = m[key]
-	}
-}
-
-func BenchmarkMegOneMap(b *testing.B) {
-	m := make(map[string]bool)
-	m[strings.Repeat("X", 1<<20)] = true
-	key := strings.Repeat("Y", 1<<20)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = m[key]
-	}
-}
-
-func BenchmarkMegEqMap(b *testing.B) {
-	m := make(map[string]bool)
-	key1 := strings.Repeat("X", 1<<20)
-	key2 := strings.Repeat("X", 1<<20) // equal but different instance
-	m[key1] = true
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = m[key2]
-	}
-}
-
-func BenchmarkMegEmptyMap(b *testing.B) {
-	m := make(map[string]bool)
-	key := strings.Repeat("X", 1<<20)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = m[key]
-	}
-}
-
-func BenchmarkSmallStrMap(b *testing.B) {
-	m := make(map[string]bool)
-	for suffix := 'A'; suffix <= 'G'; suffix++ {
-		m[fmt.Sprint(suffix)] = true
-	}
-	key := "k"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = m[key]
-	}
-}
-
-func BenchmarkMapStringKeysEight_16(b *testing.B) { benchmarkMapStringKeysEight(b, 16) }
-func BenchmarkMapStringKeysEight_32(b *testing.B) { benchmarkMapStringKeysEight(b, 32) }
-func BenchmarkMapStringKeysEight_64(b *testing.B) { benchmarkMapStringKeysEight(b, 64) }
-func BenchmarkMapStringKeysEight_1M(b *testing.B) { benchmarkMapStringKeysEight(b, 1<<20) }
-
-func benchmarkMapStringKeysEight(b *testing.B, keySize int) {
-	m := make(map[string]bool)
-	for i := 0; i < 8; i++ {
-		m[strings.Repeat("K", i+1)] = true
-	}
-	key := strings.Repeat("K", keySize)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = m[key]
-	}
-}
-
-func BenchmarkIntMap(b *testing.B) {
-	m := make(map[int]bool)
-	for i := 0; i < 8; i++ {
-		m[i] = true
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = m[7]
-	}
-}
-
-// Accessing the same keys in a row.
-func benchmarkRepeatedLookup(b *testing.B, lookupKeySize int) {
-	m := make(map[string]bool)
-	// At least bigger than a single bucket:
-	for i := 0; i < 64; i++ {
-		m[fmt.Sprintf("some key %d", i)] = true
-	}
-	base := strings.Repeat("x", lookupKeySize-1)
-	key1 := base + "1"
-	key2 := base + "2"
-	b.ResetTimer()
-	for i := 0; i < b.N/4; i++ {
-		_ = m[key1]
-		_ = m[key1]
-		_ = m[key2]
-		_ = m[key2]
-	}
-}
-
-func BenchmarkRepeatedLookupStrMapKey32(b *testing.B) { benchmarkRepeatedLookup(b, 32) }
-func BenchmarkRepeatedLookupStrMapKey1M(b *testing.B) { benchmarkRepeatedLookup(b, 1<<20) }
-
-func BenchmarkNewEmptyMap(b *testing.B) {
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		_ = make(map[int]int)
-	}
-}
-
-func BenchmarkMapIter(b *testing.B) {
-	m := make(map[int]bool)
-	for i := 0; i < 8; i++ {
-		m[i] = true
-	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		for _, _ = range m {
-		}
-	}
-}
-
-func BenchmarkMapIterEmpty(b *testing.B) {
-	m := make(map[int]bool)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		for _, _ = range m {
-		}
-	}
-}
-
-func BenchmarkSameLengthMap(b *testing.B) {
-	// long strings, same length, differ in first few
-	// and last few bytes.
-	m := make(map[string]bool)
-	s1 := "foo" + strings.Repeat("-", 100) + "bar"
-	s2 := "goo" + strings.Repeat("-", 100) + "ber"
-	m[s1] = true
-	m[s2] = true
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = m[s1]
-	}
-}
-
-type BigKey [3]int64
-
-func BenchmarkBigKeyMap(b *testing.B) {
-	m := make(map[BigKey]bool)
-	k := BigKey{3, 4, 5}
-	m[k] = true
-	for i := 0; i < b.N; i++ {
-		_ = m[k]
-	}
-}
-
-type BigVal [3]int64
-
-func BenchmarkBigValMap(b *testing.B) {
-	m := make(map[BigKey]BigVal)
-	k := BigKey{3, 4, 5}
-	m[k] = BigVal{6, 7, 8}
-	for i := 0; i < b.N; i++ {
-		_ = m[k]
-	}
-}
-
-func BenchmarkSmallKeyMap(b *testing.B) {
-	m := make(map[int16]bool)
-	m[5] = true
-	for i := 0; i < b.N; i++ {
-		_ = m[5]
-	}
-}