runtime: remove defer from standard cgo call

The endcgo function call is currently deferred in case a cgo
callback into Go panics and unwinds through cgocall. Typical cgo
calls do not have callbacks into Go, and even fewer panic, so we
pay the cost of this defer for no typical benefit.

Amazingly, there is another defer on the cgocallback path also used
to cleanup in case the Go code called by cgo panics. This CL folds
the first defer into the second, to reduce the cost of typical cgo
calls.

This reduces the overhead for a no-op cgo call significantly:

	name       old time/op  new time/op  delta
	CgoNoop-8  93.5ns ± 0%  51.1ns ± 1%  -45.34%  (p=0.016 n=4+5)

The total effect between Go 1.7 and 1.8 is even greater, as CL 29656
reduced the cost of defer recently. Hopefully a future Go release
will drop the cost of defer to nothing, making this optimization
unnecessary. But until then, this is nice.

Change-Id: Id1a5648f687a87001d95bec6842e4054bd20ee4f
Reviewed-on: https://go-review.googlesource.com/30080
Run-TryBot: David Crawshaw <crawshaw@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index f8d693060dea537e56752a3ebd5977c3e644f6fd..7d358b3346abe213cfd33b20e8db77afbe7d7431 100644 (file)
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -106,13 +106,12 @@ func cgocall(fn, arg unsafe.Pointer) int32 {
 
        /*
         * Lock g to m to ensure we stay on the same stack if we do a
-        * cgo callback. Add entry to defer stack in case of panic.
+        * cgo callback. In case of panic, unwindm calls endcgo.
         */
        lockOSThread()
        mp := getg().m
        mp.ncgocall++
        mp.ncgo++
-       defer endcgo(mp)
 
        // Reset traceback.
        mp.cgoCallers[0] = 0
@@ -132,6 +131,7 @@ func cgocall(fn, arg unsafe.Pointer) int32 {
        errno := asmcgocall(fn, arg)
        exitsyscall(0)
 
+       endcgo(mp)
        return errno
 }
 
@@ -314,6 +314,16 @@ func unwindm(restore *bool) {
        case "arm64":
                sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + 16))
        }
+
+       // Call endcgo to do the accounting that cgocall will not have a
+       // chance to do during an unwind.
+       //
+       // In the case where a a Go call originates from C, ncgo is 0
+       // and there is no matching cgocall to end.
+       if mp.ncgo > 0 {
+               endcgo(mp)
+       }
+
        releasem(mp)
 }