cmd/compile: mark empty block preemptible

Currently, a block's control instruction gets the liveness info
of the last Value in the block. However, for an empty block, the
control instruction gets the invalid liveness info and therefore
not preemptible. One example is empty infinite loop, which has
only a control instruction. The control instruction being non-
preemptible makes the whole loop non-preemptible.

Fix this by using a different, preemptible liveness info for
empty block's control. We can choose an arbitrary preemptible
liveness info, as at run time we don't really use the liveness
map at that instruction.

As before, if the last Value in the block is non-preemptible, so
is the block control. For example, the conditional branch in the
write barrier test block is still non-preemptible.

Also, only update liveness info if we are actually emitting
instructions. So zero-width Values' liveness info (which are
always invalid) won't affect the block control's liveness info.
For example, if the last Values in a block is a tuple-generating
operation and a Select, the block control instruction is still
preemptible.

Fixes #35923.

Change-Id: Ic5225f3254b07e4955f7905329b544515907642b
Reviewed-on: https://go-review.googlesource.com/c/go/+/209659
Run-TryBot: Cherry Zhang <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index bda170ec0eee3e50e514b746ee4e9d0b42e3765a..efbfa32f42e5cf996bdcd45f64d0d25d18d5af63 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -5968,23 +5968,22 @@ func genssa(f *ssa.Func, pp *Progs) {
        // Emit basic blocks
        for i, b := range f.Blocks {
                s.bstart[b.ID] = s.pp.next
-               s.pp.nextLive = LivenessInvalid
                s.lineRunStart = nil
 
+               // Attach a "default" liveness info. Normally this will be
+               // overwritten in the Values loop below for each Value. But
+               // for an empty block this will be used for its control
+               // instruction. We won't use the actual liveness map on a
+               // control instruction. Just mark it something that is
+               // preemptible.
+               s.pp.nextLive = LivenessIndex{-1, -1}
+
                // Emit values in block
                thearch.SSAMarkMoves(&s, b)
                for _, v := range b.Values {
                        x := s.pp.next
                        s.DebugFriendlySetPosFrom(v)
-                       // Attach this safe point to the next
-                       // instruction.
-                       s.pp.nextLive = s.livenessMap.Get(v)
-
-                       // Remember the liveness index of the first defer call of
-                       // the last defer exit
-                       if v.Block.Func.LastDeferExit != nil && v == v.Block.Func.LastDeferExit {
-                               s.lastDeferLiveness = s.pp.nextLive
-                       }
+
                        switch v.Op {
                        case ssa.OpInitMem:
                                // memory arg needs no code
@@ -6018,12 +6017,22 @@ func genssa(f *ssa.Func, pp *Progs) {
                                inlMarksByPos[pos] = append(inlMarksByPos[pos], p)
 
                        default:
-                               // let the backend handle it
+                               // Attach this safe point to the next
+                               // instruction.
+                               s.pp.nextLive = s.livenessMap.Get(v)
+
+                               // Remember the liveness index of the first defer call of
+                               // the last defer exit
+                               if v.Block.Func.LastDeferExit != nil && v == v.Block.Func.LastDeferExit {
+                                       s.lastDeferLiveness = s.pp.nextLive
+                               }
+
                                // Special case for first line in function; move it to the start.
                                if firstPos != src.NoXPos {
                                        s.SetPos(firstPos)
                                        firstPos = src.NoXPos
                                }
+                               // let the backend handle it
                                thearch.SSAGenValue(&s, v)
                        }
 

diff --git a/src/runtime/testdata/testprog/preempt.go b/src/runtime/testdata/testprog/preempt.go
index 1454095cde470ef55646e989aeac0e24d65c2698..1c74d0e435238afa383b9e93ad8e3807d43cc9d3 100644 (file)
--- a/src/runtime/testdata/testprog/preempt.go
+++ b/src/runtime/testdata/testprog/preempt.go
@@ -34,13 +34,19 @@ func AsyncPreempt() {
        // This is an especially interesting case for
        // LR machines.
        go func() {
-               atomic.StoreUint32(&ready2, 1)
+               atomic.AddUint32(&ready2, 1)
                frameless()
        }()
+       // Also test empty infinite loop.
+       go func() {
+               atomic.AddUint32(&ready2, 1)
+               for {
+               }
+       }()
 
        // Wait for the goroutine to stop passing through sync
        // safe-points.
-       for atomic.LoadUint32(&ready) == 0 || atomic.LoadUint32(&ready2) == 0 {
+       for atomic.LoadUint32(&ready) == 0 || atomic.LoadUint32(&ready2) < 2 {
                runtime.Gosched()
        }