schedule: add block/wake function

Background: channel is designed to be a data transfer pipe between
go routines. A scenario in gVisor is: block/wake a G (stands for a
task) by using channel, wherein there's no need for data transfer.
Channel is relatively too heavy for this case.
Channel manages Gs in a list, and has capacity. When the channel is
full, the sender will bock, and  the channel is clear, the receiver
is blocked. The receiver pushed to chan list, then schedule to run
next. The sender uses goready to wake Gs in the chan list.

A summary on our idea: introduce a new set of APIs for goroutine
wake/block.

Details:

We propose three new APIs:

GetG() -  used to get the address of goroutine.  By address, find
the goroutine G easier at go program.

WakeG() - can be used to wake one G, which can be in running/blocked
status.

BlockG() - can be used to block goroutine by itself.

How we use this in gVisor:

GuhuangLS/gvisor@97e0e6c

In futex()/epoll_wait(), we can modify it to use the new mechanism
for block and wake. Between sentry and go runtime, we maintain the
status of task Gs. Let's use futex as an example, add running status
at goruntime, NoWake,Waked,Blocked.

At sentry, one task/G can use BlockG() to block, like   <-chan. Other
tasks/Gs can use WakeG() to wake the task/G which is blocked by BlockG()
, like chan <-. Based on a basic prototype of Go and gVisor, we use the
program in google/gvisor#2033(comment) as the test program.

We can see 22% improvement by test case:
google/gvisor#2033.

Signed-off-by: liushi <[email protected]>

Author: GuhuangLS

src/runtime/block_wake_test.go

@@ -0,0 +1,36 @@
+// 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.
+
+// Futex is only available on DragonFly BSD, FreeBSD and Linux.
+// The race detector emits calls to split stack functions so it breaks
+// the test.
+
+// +build dragonfly freebsd linux
+// +build !race
+
+package runtime_test
+
+import (
+	"runtime"
+	"testing"
+	"time"
+)
+
+var testG []uintptr
+
+func TestBlockWakeG(t *testing.T) {
+	for i := 0; i < 1; i++ {
+		go func() {
+			testG = append(testG, runtime.GetG())
+			runtime.BlockG()
+			runtime.ClearGStatus()
+		}()
+	}
+	<-time.After(time.Second)
+
+	for _, g := range testG {
+		runtime.WakeG(g)
+	}
+	<-time.After(time.Second)
+}

src/runtime/proc.go

@@ -3284,6 +3284,60 @@ func injectglist(glist *gList) {
 	}
 }
 
+const (
+	gStatusNoWake  = 0
+	gStatusWaked   = 1
+	gStatusBlocked = 2
+)
+
+func GetG() uintptr {
+	gp := getg()
+	return uintptr(unsafe.Pointer(gp))
+}
+
+func ClearGStatus() {
+	lock(&sched.wakeLock)
+	gp := getg()
+	gp.wakeStatus = gStatusNoWake
+	unlock(&sched.wakeLock)
+}
+
+func WakeG(g uintptr) {
+	gp := guintptr(g).ptr()
+	if gp == nil {
+		return
+	}
+	lock(&sched.wakeLock)
+	if gp.wakeStatus != gStatusBlocked {
+		gp.wakeStatus = gStatusWaked
+		unlock(&sched.wakeLock)
+		return
+	}
+	gp.wakeStatus = gStatusNoWake
+	unlock(&sched.wakeLock)
+	goready(gp, 1)
+}
+
+func gosched_block(gp *g) {
+	dropg()
+	lock(&sched.wakeLock)
+	if gp.wakeStatus == gStatusWaked {
+		gp.wakeStatus = gStatusNoWake
+		unlock(&sched.wakeLock)
+		casgstatus(gp, _Grunning, _Grunnable)
+		execute(gp, false) // Schedule it back, never returns.
+		return
+	}
+	gp.wakeStatus = gStatusBlocked
+	casgstatus(gp, _Grunning, _Gwaiting)
+	unlock(&sched.wakeLock)
+	schedule()
+}
+
+func BlockG() {
+	mcall(gosched_block)
+}
+
 // One round of scheduler: find a runnable goroutine and execute it.
 // Never returns.
 func schedule() {

src/runtime/runtime2.go

@@ -431,6 +431,7 @@ type g struct {
 	// 3. By debugCallWrap to pass parameters to a new goroutine because allocating a
 	//    closure in the runtime is forbidden.
 	param        unsafe.Pointer
+	wakeStatus   uint32
 	atomicstatus uint32
 	stackLock    uint32 // sigprof/scang lock; TODO: fold in to atomicstatus
 	goid         int64
@@ -754,7 +755,8 @@ type schedt struct {
 	lastpoll  uint64 // time of last network poll, 0 if currently polling
 	pollUntil uint64 // time to which current poll is sleeping
 
-	lock mutex
+	lock     mutex
+	wakeLock mutex
 
 	// When increasing nmidle, nmidlelocked, nmsys, or nmfreed, be
 	// sure to call checkdead().