reflect: cache IsVariadic in Call

Taking a look at a CPU profile, IsVariadic was calculated multiple times
unnecessarily.

I also added a new BechmarkCallMethod to measure this use-case.

name                       old time/op    new time/op    delta
Call-16                      20.3ns ± 8%    20.3ns ±16%    ~     (p=0.443 n=18+20)
CallMethod-16                99.2ns ± 3%    90.1ns ± 2%  -9.22%  (p=0.000 n=20+17)
CallArgCopy/size=128-16      15.0ns ± 2%    14.5ns ± 3%  -2.76%  (p=0.000 n=20+19)
CallArgCopy/size=256-16      15.9ns ± 7%    15.3ns ± 5%  -4.26%  (p=0.000 n=20+20)
CallArgCopy/size=1024-16     17.6ns ± 7%    17.2ns ± 6%  -1.73%  (p=0.044 n=19+20)
CallArgCopy/size=4096-16     25.3ns ± 4%    24.9ns ± 4%  -1.66%  (p=0.016 n=18+20)
CallArgCopy/size=65536-16     375ns ± 4%     376ns ± 4%    ~     (p=0.644 n=20+20)

name                       old alloc/op   new alloc/op   delta
Call-16                       0.00B          0.00B         ~     (all equal)
CallMethod-16                 0.00B          0.00B         ~     (all equal)

name                       old allocs/op  new allocs/op  delta
Call-16                        0.00           0.00         ~     (all equal)
CallMethod-16                  0.00           0.00         ~     (all equal)

name                       old speed      new speed      delta
CallArgCopy/size=128-16    8.56GB/s ± 2%  8.80GB/s ± 3%  +2.84%  (p=0.000 n=20+19)
CallArgCopy/size=256-16    16.1GB/s ± 6%  16.8GB/s ± 5%  +4.45%  (p=0.000 n=20+20)
CallArgCopy/size=1024-16   58.2GB/s ± 7%  59.4GB/s ± 6%  +2.16%  (p=0.026 n=20+20)
CallArgCopy/size=4096-16    161GB/s ± 4%   165GB/s ± 4%  +1.95%  (p=0.007 n=17+20)
CallArgCopy/size=65536-16   175GB/s ± 4%   174GB/s ± 4%    ~     (p=0.640 n=20+20)

Updates golang#7818

Signed-off-by: Ignacio Hagopian <jsign.uy@gmail.com>

Author: jsign

src/reflect/value.go

@@ -375,8 +375,9 @@ func (v Value) call(op string, in []Value) []Value {
 
 	isSlice := op == "CallSlice"
 	n := t.NumIn()
+	isVariadic := t.IsVariadic()
 	if isSlice {
-		if !t.IsVariadic() {
+		if !isVariadic {
 			panic("reflect: CallSlice of non-variadic function")
 		}
 		if len(in) < n {
@@ -386,13 +387,13 @@ func (v Value) call(op string, in []Value) []Value {
 			panic("reflect: CallSlice with too many input arguments")
 		}
 	} else {
-		if t.IsVariadic() {
+		if isVariadic {
 			n--
 		}
 		if len(in) < n {
 			panic("reflect: Call with too few input arguments")
 		}
-		if !t.IsVariadic() && len(in) > n {
+		if !isVariadic && len(in) > n {
 			panic("reflect: Call with too many input arguments")
 		}
 	}
@@ -406,7 +407,7 @@ func (v Value) call(op string, in []Value) []Value {
 			panic("reflect: " + op + " using " + xt.String() + " as type " + targ.String())
 		}
 	}
-	if !isSlice && t.IsVariadic() {
+	if !isSlice && isVariadic {
 		// prepare slice for remaining values
 		m := len(in) - n
 		slice := MakeSlice(t.In(n), m, m)