runtime: call mallocgc directly from makeslice and growslice

The extra checks provided by newarray are
redundant in these cases.

This shrinks by one frame the call stack expected
by the pprof test.

name                      old time/op  new time/op  delta
MakeSlice-8               34.3ns ± 2%  30.5ns ± 3%  -11.03%  (p=0.000 n=24+22)
GrowSlicePtr-8             134ns ± 2%   129ns ± 3%   -3.25%  (p=0.000 n=25+24)

Change-Id: Icd828655906b921c732701fd9d61da3fa217b0af
Reviewed-on: https://go-review.googlesource.com/22276
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

diff --git a/src/runtime/pprof/mprof_test.go b/src/runtime/pprof/mprof_test.go
index d15102c7030bc78e905937c1f7eb264d314d4ebd..0fff9d46d9e139f1c0c297b5abf102bd66090828 100644 (file)
--- a/src/runtime/pprof/mprof_test.go
+++ b/src/runtime/pprof/mprof_test.go
@@ -82,7 +82,7 @@ func TestMemoryProfiler(t *testing.T) {
 #      0x[0-9,a-f]+    runtime/pprof_test\.TestMemoryProfiler\+0x[0-9,a-f]+    .*/runtime/pprof/mprof_test.go:61
 `, (1<<10)*memoryProfilerRun, (1<<20)*memoryProfilerRun),
 
-               fmt.Sprintf(`0: 0 \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
+               fmt.Sprintf(`0: 0 \[%v: %v\] @ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+ 0x[0-9,a-f]+
 #      0x[0-9,a-f]+    runtime/pprof_test\.allocateTransient2M\+0x[0-9,a-f]+   .*/runtime/pprof/mprof_test.go:27
 #      0x[0-9,a-f]+    runtime/pprof_test\.TestMemoryProfiler\+0x[0-9,a-f]+    .*/runtime/pprof/mprof_test.go:62
 `, memoryProfilerRun, (2<<20)*memoryProfilerRun),

diff --git a/src/runtime/slice.go b/src/runtime/slice.go
index f9414d7658894299b2ff65a5bda241562bb20ad6..873e97ebff3821d84083a3ee42d230b12b10bfc4 100644 (file)
--- a/src/runtime/slice.go
+++ b/src/runtime/slice.go
@@ -55,7 +55,12 @@ func makeslice(t *slicetype, len64, cap64 int64) slice {
                panic(errorString("makeslice: cap out of range"))
        }
 
-       p := newarray(t.elem, uintptr(cap))
+       et := t.elem
+       var flags uint32
+       if et.kind&kindNoPointers != 0 {
+               flags = flagNoScan
+       }
+       p := mallocgc(et.size*uintptr(cap), et, flags)
        return slice{p, len, cap}
 }
 
@@ -130,7 +135,7 @@ func growslice(t *slicetype, old slice, cap int) slice {
                memclr(add(p, lenmem), capmem-lenmem)
        } else {
                // Note: can't use rawmem (which avoids zeroing of memory), because then GC can scan uninitialized memory.
-               p = newarray(et, uintptr(newcap))
+               p = mallocgc(capmem, et, 0)
                if !writeBarrier.enabled {
                        memmove(p, old.array, lenmem)
                } else {