mirror of
https://github.com/golang/go
synced 2024-11-15 01:20:28 -07:00
6ed4661807
match: m = make([]T, x); copy(m, s) for pointer free T and x==len(s) rewrite to: m = mallocgc(x*elemsize(T), nil, false); memmove(&m, &s, x*elemsize(T)) otherwise rewrite to: m = makeslicecopy([]T, x, s) This avoids memclear and shading of pointers in the newly created slice before the copy. With this CL "s" is only be allowed to bev a variable and not a more complex expression. This restriction could be lifted in future versions of this optimization when it can be proven that "s" is not referencing "m". Triggers 450 times during make.bash.. Reduces go binary size by ~8 kbyte. name old time/op new time/op delta MakeSliceCopy/mallocmove/Byte 71.1ns ± 1% 65.8ns ± 0% -7.49% (p=0.000 n=10+9) MakeSliceCopy/mallocmove/Int 71.2ns ± 1% 66.0ns ± 0% -7.27% (p=0.000 n=10+8) MakeSliceCopy/mallocmove/Ptr 104ns ± 4% 99ns ± 1% -5.13% (p=0.000 n=10+10) MakeSliceCopy/makecopy/Byte 70.3ns ± 0% 68.0ns ± 0% -3.22% (p=0.000 n=10+9) MakeSliceCopy/makecopy/Int 70.3ns ± 0% 68.5ns ± 1% -2.59% (p=0.000 n=9+10) MakeSliceCopy/makecopy/Ptr 102ns ± 0% 99ns ± 1% -2.97% (p=0.000 n=9+9) MakeSliceCopy/nilappend/Byte 75.4ns ± 0% 74.9ns ± 2% -0.63% (p=0.015 n=9+9) MakeSliceCopy/nilappend/Int 75.6ns ± 0% 76.4ns ± 3% ~ (p=0.245 n=9+10) MakeSliceCopy/nilappend/Ptr 107ns ± 0% 108ns ± 1% +0.93% (p=0.005 n=9+10) Fixes #26252 Change-Id: Iec553dd1fef6ded16197216a472351c8799a8e71 Reviewed-on: https://go-review.googlesource.com/c/go/+/146719 Reviewed-by: Keith Randall <khr@golang.org> Run-TryBot: Martin Möhrmann <moehrmann@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
150 lines
5.5 KiB
Go
150 lines
5.5 KiB
Go
// run
|
|
|
|
// 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 main
|
|
|
|
import (
|
|
"strings"
|
|
"unsafe"
|
|
)
|
|
|
|
func main() {
|
|
n := -1
|
|
testInts(uint64(n))
|
|
testBytes(uint64(n))
|
|
|
|
var t *byte
|
|
if unsafe.Sizeof(t) == 8 {
|
|
// Test mem > maxAlloc
|
|
testInts(1 << 59)
|
|
|
|
// Test elem.size*cap overflow
|
|
testInts(1<<63 - 1)
|
|
|
|
testInts(1<<64 - 1)
|
|
testBytes(1<<64 - 1)
|
|
} else {
|
|
testInts(1<<31 - 1)
|
|
|
|
// Test elem.size*cap overflow
|
|
testInts(1<<32 - 1)
|
|
testBytes(1<<32 - 1)
|
|
}
|
|
}
|
|
|
|
func shouldPanic(str string, f func()) {
|
|
defer func() {
|
|
err := recover()
|
|
if err == nil {
|
|
panic("did not panic")
|
|
}
|
|
s := err.(error).Error()
|
|
if !strings.Contains(s, str) {
|
|
panic("got panic " + s + ", want " + str)
|
|
}
|
|
}()
|
|
|
|
f()
|
|
}
|
|
|
|
func testInts(n uint64) {
|
|
testMakeInts(n)
|
|
testMakeCopyInts(n)
|
|
testMakeInAppendInts(n)
|
|
}
|
|
|
|
func testBytes(n uint64) {
|
|
testMakeBytes(n)
|
|
testMakeCopyBytes(n)
|
|
testMakeInAppendBytes(n)
|
|
}
|
|
|
|
// Test make panics for given length or capacity n.
|
|
func testMakeInts(n uint64) {
|
|
type T []int
|
|
shouldPanic("len out of range", func() { _ = make(T, int(n)) })
|
|
shouldPanic("cap out of range", func() { _ = make(T, 0, int(n)) })
|
|
shouldPanic("len out of range", func() { _ = make(T, uint(n)) })
|
|
shouldPanic("cap out of range", func() { _ = make(T, 0, uint(n)) })
|
|
shouldPanic("len out of range", func() { _ = make(T, int64(n)) })
|
|
shouldPanic("cap out of range", func() { _ = make(T, 0, int64(n)) })
|
|
shouldPanic("len out of range", func() { _ = make(T, uint64(n)) })
|
|
shouldPanic("cap out of range", func() { _ = make(T, 0, uint64(n)) })
|
|
}
|
|
|
|
func testMakeBytes(n uint64) {
|
|
type T []byte
|
|
shouldPanic("len out of range", func() { _ = make(T, int(n)) })
|
|
shouldPanic("cap out of range", func() { _ = make(T, 0, int(n)) })
|
|
shouldPanic("len out of range", func() { _ = make(T, uint(n)) })
|
|
shouldPanic("cap out of range", func() { _ = make(T, 0, uint(n)) })
|
|
shouldPanic("len out of range", func() { _ = make(T, int64(n)) })
|
|
shouldPanic("cap out of range", func() { _ = make(T, 0, int64(n)) })
|
|
shouldPanic("len out of range", func() { _ = make(T, uint64(n)) })
|
|
shouldPanic("cap out of range", func() { _ = make(T, 0, uint64(n)) })
|
|
}
|
|
|
|
// Test make+copy panics since the gc compiler optimizes these
|
|
// to runtime.makeslicecopy calls.
|
|
func testMakeCopyInts(n uint64) {
|
|
type T []int
|
|
var c = make(T, 8)
|
|
shouldPanic("len out of range", func() { x := make(T, int(n)); copy(x, c) })
|
|
shouldPanic("cap out of range", func() { x := make(T, 0, int(n)); copy(x, c) })
|
|
shouldPanic("len out of range", func() { x := make(T, uint(n)); copy(x, c) })
|
|
shouldPanic("cap out of range", func() { x := make(T, 0, uint(n)); copy(x, c) })
|
|
shouldPanic("len out of range", func() { x := make(T, int64(n)); copy(x, c) })
|
|
shouldPanic("cap out of range", func() { x := make(T, 0, int64(n)); copy(x, c) })
|
|
shouldPanic("len out of range", func() { x := make(T, uint64(n)); copy(x, c) })
|
|
shouldPanic("cap out of range", func() { x := make(T, 0, uint64(n)); copy(x, c) })
|
|
}
|
|
|
|
func testMakeCopyBytes(n uint64) {
|
|
type T []byte
|
|
var c = make(T, 8)
|
|
shouldPanic("len out of range", func() { x := make(T, int(n)); copy(x, c) })
|
|
shouldPanic("cap out of range", func() { x := make(T, 0, int(n)); copy(x, c) })
|
|
shouldPanic("len out of range", func() { x := make(T, uint(n)); copy(x, c) })
|
|
shouldPanic("cap out of range", func() { x := make(T, 0, uint(n)); copy(x, c) })
|
|
shouldPanic("len out of range", func() { x := make(T, int64(n)); copy(x, c) })
|
|
shouldPanic("cap out of range", func() { x := make(T, 0, int64(n)); copy(x, c) })
|
|
shouldPanic("len out of range", func() { x := make(T, uint64(n)); copy(x, c) })
|
|
shouldPanic("cap out of range", func() { x := make(T, 0, uint64(n)); copy(x, c) })
|
|
}
|
|
|
|
// Test make in append panics for int slices since the gc compiler optimizes makes in appends.
|
|
func testMakeInAppendInts(n uint64) {
|
|
type T []int
|
|
for _, length := range []int{0, 1} {
|
|
t := make(T, length)
|
|
shouldPanic("len out of range", func() { _ = append(t, make(T, int(n))...) })
|
|
shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int(n))...) })
|
|
shouldPanic("len out of range", func() { _ = append(t, make(T, int64(n))...) })
|
|
shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int64(n))...) })
|
|
shouldPanic("len out of range", func() { _ = append(t, make(T, uint64(n))...) })
|
|
shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint64(n))...) })
|
|
shouldPanic("len out of range", func() { _ = append(t, make(T, int(n))...) })
|
|
shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int(n))...) })
|
|
shouldPanic("len out of range", func() { _ = append(t, make(T, uint(n))...) })
|
|
shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint(n))...) })
|
|
}
|
|
}
|
|
|
|
func testMakeInAppendBytes(n uint64) {
|
|
type T []byte
|
|
for _, length := range []int{0, 1} {
|
|
t := make(T, length)
|
|
shouldPanic("len out of range", func() { _ = append(t, make(T, int(n))...) })
|
|
shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int(n))...) })
|
|
shouldPanic("len out of range", func() { _ = append(t, make(T, uint(n))...) })
|
|
shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint(n))...) })
|
|
shouldPanic("len out of range", func() { _ = append(t, make(T, int64(n))...) })
|
|
shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int64(n))...) })
|
|
shouldPanic("len out of range", func() { _ = append(t, make(T, uint64(n))...) })
|
|
shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint64(n))...) })
|
|
}
|
|
}
|