code review 10042044: runtime: improve scheduler fairness

src/pkg/runtime/proc_test.go

 // Copyright 2011 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.
 
 package runtime_test
 
 import (
         "math"
         "runtime"
         "sync/atomic"
+        "syscall"
         "testing"
         "time"
 )
 
 var stop = make(chan bool, 1)
 
 func perpetuumMobile() {
         select {
         case <-stop:
         default:
@@ skipping 77 matching lines @@
         go func() {
                 runtime.LockOSThread()
                 for i := 0; i < N; i++ {
                         c <- true
                 }
                 runtime.UnlockOSThread()
         }()
         for i := 0; i < N; i++ {
                 <-c
         }
+}
+
+func TestTimerFairness(t *testing.T) {
+        done := make(chan bool)
+        c := make(chan bool)
+        for i := 0; i < 2; i++ {
+                go func() {
+                        for {
+                                select {
+                                case c <- true:
+                                case <-done:
+                                        return
+                                }
+                        }
+                }()
+        }
+
+        timer := time.After(20 * time.Millisecond)
+        for {
+                select {
+                case <-c:
+                case <-timer:
+                        close(done)
+                        return
+                }
+        }
+}
+
+func TestTimerFairness2(t *testing.T) {
+        done := make(chan bool)
+        c := make(chan bool)
+        for i := 0; i < 2; i++ {
+                go func() {
+                        timer := time.After(20 * time.Millisecond)
+                        var buf [1]byte
+                        for {
+                                syscall.Read(0, buf[0:0])
+                                select {
+                                case c <- true:
+                                case <-c:
+                                case <-timer:
+                                        done <- true
+                                        return
+                                }
+                        }
+                }()
+        }
+        <-done
+        <-done
 }
 
 func stackGrowthRecursive(i int) {
         var pad [128]uint64
         if i != 0 && pad[0] == 0 {
                 stackGrowthRecursive(i - 1)
         }
 }
 
 func TestSchedLocalQueue(t *testing.T) {
@@ skipping 158 matching lines @@
                                 for k := k0; k < k1; k++ {
                                         C[i][j] += A[i][k] * B[k][j]
                                 }
                         }
                 }
         }
         if done != nil {
                 done <- struct{}{}
         }
 }