Revert "runtime: disable use of runnext on wasm"

This reverts CL 557437.

Reason for revert: Appears to have broken wasip1 builders.

For #65178.

Change-Id: I59c1a310eb56589c768536fe444c1efaf862f8b0
Reviewed-on: https://go-review.googlesource.com/c/go/+/559237
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Michael Pratt <mpratt@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>

diff --git a/src/net/net_fake.go b/src/net/net_fake.go
index f7eb28e01ac37dfc72b53470cf449135294d4cae..2d1e137b6dbadab6c579e48f368f0f2100d8de4b 100644 (file)
--- a/src/net/net_fake.go
+++ b/src/net/net_fake.go
@@ -14,6 +14,7 @@ import (
        "errors"
        "io"
        "os"
+       "runtime"
        "sync"
        "sync/atomic"
        "syscall"
@@ -516,6 +517,14 @@ func (pq *packetQueue) send(dt *deadlineTimer, b []byte, from sockaddr, block bo
                full = pq.full
        }
 
+       // Before we check dt.expired, yield to other goroutines.
+       // This may help to prevent starvation of the goroutine that runs the
+       // deadlineTimer's time.After callback.
+       //
+       // TODO(#65178): Remove this when the runtime scheduler no longer starves
+       // runnable goroutines.
+       runtime.Gosched()
+
        select {
        case <-dt.expired:
                return 0, os.ErrDeadlineExceeded
@@ -567,6 +576,14 @@ func (pq *packetQueue) recvfrom(dt *deadlineTimer, b []byte, wholePacket bool, c
                empty = pq.empty
        }
 
+       // Before we check dt.expired, yield to other goroutines.
+       // This may help to prevent starvation of the goroutine that runs the
+       // deadlineTimer's time.After callback.
+       //
+       // TODO(#65178): Remove this when the runtime scheduler no longer starves
+       // runnable goroutines.
+       runtime.Gosched()
+
        select {
        case <-dt.expired:
                return 0, nil, os.ErrDeadlineExceeded

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 410bd011694f1b0730d4b54b68c80eb6285c243c..c1b3ce20d513daeb388dd779b06d43c868ce106e 100644 (file)
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -167,7 +167,7 @@ func main() {
        // Allow newproc to start new Ms.
        mainStarted = true
 
-       if haveSysmon {
+       if GOARCH != "wasm" { // no threads on wasm yet, so no sysmon
                systemstack(func() {
                        newm(sysmon, nil, -1)
                })
@@ -5933,11 +5933,6 @@ var forcegcperiod int64 = 2 * 60 * 1e9
 // golang.org/issue/42515 is needed on NetBSD.
 var needSysmonWorkaround bool = false
 
-// haveSysmon indicates whether there is sysmon thread support.
-//
-// No threads on wasm yet, so no sysmon.
-const haveSysmon = GOARCH != "wasm"
-
 // Always runs without a P, so write barriers are not allowed.
 //
 //go:nowritebarrierrec
@@ -6118,10 +6113,7 @@ func retake(now int64) uint32 {
                s := pp.status
                sysretake := false
                if s == _Prunning || s == _Psyscall {
-                       // Preempt G if it's running on the same schedtick for
-                       // too long. This could be from a single long-running
-                       // goroutine or a sequence of goroutines run via
-                       // runnext, which share a single schedtick time slice.
+                       // Preempt G if it's running for too long.
                        t := int64(pp.schedtick)
                        if int64(pd.schedtick) != t {
                                pd.schedtick = uint32(t)
@@ -6632,17 +6624,6 @@ const randomizeScheduler = raceenabled
 // If the run queue is full, runnext puts g on the global queue.
 // Executed only by the owner P.
 func runqput(pp *p, gp *g, next bool) {
-       if !haveSysmon && next {
-               // A runnext goroutine shares the same time slice as the
-               // current goroutine (inheritTime from runqget). To prevent a
-               // ping-pong pair of goroutines from starving all others, we
-               // depend on sysmon to preempt "long-running goroutines". That
-               // is, any set of goroutines sharing the same time slice.
-               //
-               // If there is no sysmon, we must avoid runnext entirely or
-               // risk starvation.
-               next = false
-       }
        if randomizeScheduler && next && randn(2) == 0 {
                next = false
        }

diff --git a/src/time/sleep_test.go b/src/time/sleep_test.go
index 36e203e65e5105e5f72443ff2efb4f4979395669..b25606dfed762353b23fa82d02d797cef9acc009 100644 (file)
--- a/src/time/sleep_test.go
+++ b/src/time/sleep_test.go
@@ -96,6 +96,11 @@ func TestAfterFuncStarvation(t *testing.T) {
        // the AfterFunc goroutine instead of the runnable channel goroutine.
        // However, in https://go.dev/issue/65178 this was observed to live-lock
        // on wasip1/wasm and js/wasm after <10000 runs.
+
+       if runtime.GOARCH == "wasm" {
+               testenv.SkipFlaky(t, 65178)
+       }
+
        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))
 
        var (