runtime: improve makechan memory checks and allocation calls

Use mallogc instead of newarray to save some overhead since
makechan already checks for _MaxMem constraints.

Flattens the if else construct that determines if buf and hchan struct
should be allocated in one mallocgc call and where buf should point to.

Uses maxSliceCap to avoid divisions similar to makeslice.

name                old time/op  new time/op  delta
MakeChan/Byte       82.0ns ± 8%  81.4ns ± 7%    ~     (p=0.643 n=10+10)
MakeChan/Int        97.9ns ± 2%  96.6ns ± 2%  -1.40%  (p=0.009 n=10+10)
MakeChan/Ptr         128ns ± 3%   120ns ± 1%  -6.63%  (p=0.000 n=10+10)
MakeChan/Struct/0   66.7ns ± 4%  66.4ns ± 2%    ~     (p=0.697 n=10+10)
MakeChan/Struct/32   136ns ± 1%   130ns ± 0%  -4.42%  (p=0.000 n=10+10)
MakeChan/Struct/40   150ns ± 1%   150ns ± 1%    ~     (p=0.725 n=10+10)

Change-Id: Ibb5675d0843a072aae2bfa58ecd39cf4cd926533
Reviewed-on: https://go-review.googlesource.com/55132
Run-TryBot: Martin Möhrmann <moehrmann@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

diff --git a/src/runtime/chan.go b/src/runtime/chan.go
index 872f17bb8433b204c26d07956c9128bb8ce9a671..f20aaef19ed9a548be37c86c4697cd022d564282 100644 (file)
--- a/src/runtime/chan.go
+++ b/src/runtime/chan.go
@@ -77,29 +77,33 @@ func makechan(t *chantype, size int) *hchan {
        if hchanSize%maxAlign != 0 || elem.align > maxAlign {
                throw("makechan: bad alignment")
        }
-       if size < 0 || (elem.size > 0 && uintptr(size) > (_MaxMem-hchanSize)/elem.size) {
+
+       if size < 0 || uintptr(size) > maxSliceCap(elem.size) || uintptr(size)*elem.size > _MaxMem-hchanSize {
                panic(plainError("makechan: size out of range"))
        }
 
+       // Hchan does not contain pointers interesting for GC when elements stored in buf do not contain pointers.
+       // buf points into the same allocation, elemtype is persistent.
+       // SudoG's are referenced from their owning thread so they can't be collected.
+       // TODO(dvyukov,rlh): Rethink when collector can move allocated objects.
        var c *hchan
-       if elem.kind&kindNoPointers != 0 || size == 0 {
-               // Allocate memory in one call.
-               // Hchan does not contain pointers interesting for GC in this case:
-               // buf points into the same allocation, elemtype is persistent.
-               // SudoG's are referenced from their owning thread so they can't be collected.
-               // TODO(dvyukov,rlh): Rethink when collector can move allocated objects.
+       switch {
+       case size == 0 || elem.size == 0:
+               // Queue or element size is zero.
+               c = (*hchan)(mallocgc(hchanSize, nil, true))
+               // Race detector uses this location for synchronization.
+               c.buf = unsafe.Pointer(c)
+       case elem.kind&kindNoPointers != 0:
+               // Elements do not contain pointers.
+               // Allocate hchan and buf in one call.
                c = (*hchan)(mallocgc(hchanSize+uintptr(size)*elem.size, nil, true))
-               if size > 0 && elem.size != 0 {
-                       c.buf = add(unsafe.Pointer(c), hchanSize)
-               } else {
-                       // race detector uses this location for synchronization
-                       // Also prevents us from pointing beyond the allocation (see issue 9401).
-                       c.buf = unsafe.Pointer(c)
-               }
-       } else {
+               c.buf = add(unsafe.Pointer(c), hchanSize)
+       default:
+               // Elements contain pointers.
                c = new(hchan)
-               c.buf = newarray(elem, int(size))
+               c.buf = mallocgc(uintptr(size)*elem.size, elem, true)
        }
+
        c.elemsize = uint16(elem.size)
        c.elemtype = elem
        c.dataqsiz = uint(size)