libgo/go/sync/mutex_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // GOMAXPROCS=10 go test
   6
   7 package sync_test
   8
   9 import (
  10         "fmt"
  11         "internal/testenv"
  12         "os"
  13         "os/exec"
  14         "runtime"
  15         "strings"
  16         . "sync"
  17         "testing"
  18         "time"
  19 )
  20
  21 func HammerSemaphore(s *uint32, loops int, cdone chan bool) {
  22         for i := 0; i < loops; i++ {
  23                 Runtime_Semacquire(s)
  24                 Runtime_Semrelease(s, false, 0)
  25         }
  26         cdone <- true
  27 }
  28
  29 func TestSemaphore(t *testing.T) {
  30         s := new(uint32)
  31         *s = 1
  32         c := make(chan bool)
  33         for i := 0; i < 10; i++ {
  34                 go HammerSemaphore(s, 1000, c)
  35         }
  36         for i := 0; i < 10; i++ {
  37                 <-c
  38         }
  39 }
  40
  41 func BenchmarkUncontendedSemaphore(b *testing.B) {
  42         s := new(uint32)
  43         *s = 1
  44         HammerSemaphore(s, b.N, make(chan bool, 2))
  45 }
  46
  47 func BenchmarkContendedSemaphore(b *testing.B) {
  48         b.StopTimer()
  49         s := new(uint32)
  50         *s = 1
  51         c := make(chan bool)
  52         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
  53         b.StartTimer()
  54
  55         go HammerSemaphore(s, b.N/2, c)
  56         go HammerSemaphore(s, b.N/2, c)
  57         <-c
  58         <-c
  59 }
  60
  61 func HammerMutex(m *Mutex, loops int, cdone chan bool) {
  62         for i := 0; i < loops; i++ {
  63                 if i%3 == 0 {
  64                         if m.TryLock() {
  65                                 m.Unlock()
  66                         }
  67                         continue
  68                 }
  69                 m.Lock()
  70                 m.Unlock()
  71         }
  72         cdone <- true
  73 }
  74
  75 func TestMutex(t *testing.T) {
  76         if n := runtime.SetMutexProfileFraction(1); n != 0 {
  77                 t.Logf("got mutexrate %d expected 0", n)
  78         }
  79         defer runtime.SetMutexProfileFraction(0)
  80
  81         m := new(Mutex)
  82
  83         m.Lock()
  84         if m.TryLock() {
  85                 t.Fatalf("TryLock succeeded with mutex locked")
  86         }
  87         m.Unlock()
  88         if !m.TryLock() {
  89                 t.Fatalf("TryLock failed with mutex unlocked")
  90         }
  91         m.Unlock()
  92
  93         c := make(chan bool)
  94         for i := 0; i < 10; i++ {
  95                 go HammerMutex(m, 1000, c)
  96         }
  97         for i := 0; i < 10; i++ {
  98                 <-c
  99         }
 100 }
 101
 102 var misuseTests = []struct {
 103         name string
 104         f    func()
 105 }{
 106         {
 107                 "Mutex.Unlock",
 108                 func() {
 109                         var mu Mutex
 110                         mu.Unlock()
 111                 },
 112         },
 113         {
 114                 "Mutex.Unlock2",
 115                 func() {
 116                         var mu Mutex
 117                         mu.Lock()
 118                         mu.Unlock()
 119                         mu.Unlock()
 120                 },
 121         },
 122         {
 123                 "RWMutex.Unlock",
 124                 func() {
 125                         var mu RWMutex
 126                         mu.Unlock()
 127                 },
 128         },
 129         {
 130                 "RWMutex.Unlock2",
 131                 func() {
 132                         var mu RWMutex
 133                         mu.RLock()
 134                         mu.Unlock()
 135                 },
 136         },
 137         {
 138                 "RWMutex.Unlock3",
 139                 func() {
 140                         var mu RWMutex
 141                         mu.Lock()
 142                         mu.Unlock()
 143                         mu.Unlock()
 144                 },
 145         },
 146         {
 147                 "RWMutex.RUnlock",
 148                 func() {
 149                         var mu RWMutex
 150                         mu.RUnlock()
 151                 },
 152         },
 153         {
 154                 "RWMutex.RUnlock2",
 155                 func() {
 156                         var mu RWMutex
 157                         mu.Lock()
 158                         mu.RUnlock()
 159                 },
 160         },
 161         {
 162                 "RWMutex.RUnlock3",
 163                 func() {
 164                         var mu RWMutex
 165                         mu.RLock()
 166                         mu.RUnlock()
 167                         mu.RUnlock()
 168                 },
 169         },
 170 }
 171
 172 func init() {
 173         if len(os.Args) == 3 && os.Args[1] == "TESTMISUSE" {
 174                 for _, test := range misuseTests {
 175                         if test.name == os.Args[2] {
 176                                 func() {
 177                                         defer func() { recover() }()
 178                                         test.f()
 179                                 }()
 180                                 fmt.Printf("test completed\n")
 181                                 os.Exit(0)
 182                         }
 183                 }
 184                 fmt.Printf("unknown test\n")
 185                 os.Exit(0)
 186         }
 187 }
 188
 189 func TestMutexMisuse(t *testing.T) {
 190         testenv.MustHaveExec(t)
 191         for _, test := range misuseTests {
 192                 out, err := exec.Command(os.Args[0], "TESTMISUSE", test.name).CombinedOutput()
 193                 if err == nil || !strings.Contains(string(out), "unlocked") {
 194                         t.Errorf("%s: did not find failure with message about unlocked lock: %s\n%s\n", test.name, err, out)
 195                 }
 196         }
 197 }
 198
 199 func TestMutexFairness(t *testing.T) {
 200         var mu Mutex
 201         stop := make(chan bool)
 202         defer close(stop)
 203         go func() {
 204                 for {
 205                         mu.Lock()
 206                         time.Sleep(100 * time.Microsecond)
 207                         mu.Unlock()
 208                         select {
 209                         case <-stop:
 210                                 return
 211                         default:
 212                         }
 213                 }
 214         }()
 215         done := make(chan bool, 1)
 216         go func() {
 217                 for i := 0; i < 10; i++ {
 218                         time.Sleep(100 * time.Microsecond)
 219                         mu.Lock()
 220                         mu.Unlock()
 221                 }
 222                 done <- true
 223         }()
 224         select {
 225         case <-done:
 226         case <-time.After(10 * time.Second):
 227                 t.Fatalf("can't acquire Mutex in 10 seconds")
 228         }
 229 }
 230
 231 func BenchmarkMutexUncontended(b *testing.B) {
 232         type PaddedMutex struct {
 233                 Mutex
 234                 pad [128]uint8
 235         }
 236         b.RunParallel(func(pb *testing.PB) {
 237                 var mu PaddedMutex
 238                 for pb.Next() {
 239                         mu.Lock()
 240                         mu.Unlock()
 241                 }
 242         })
 243 }
 244
 245 func benchmarkMutex(b *testing.B, slack, work bool) {
 246         var mu Mutex
 247         if slack {
 248                 b.SetParallelism(10)
 249         }
 250         b.RunParallel(func(pb *testing.PB) {
 251                 foo := 0
 252                 for pb.Next() {
 253                         mu.Lock()
 254                         mu.Unlock()
 255                         if work {
 256                                 for i := 0; i < 100; i++ {
 257                                         foo *= 2
 258                                         foo /= 2
 259                                 }
 260                         }
 261                 }
 262                 _ = foo
 263         })
 264 }
 265
 266 func BenchmarkMutex(b *testing.B) {
 267         benchmarkMutex(b, false, false)
 268 }
 269
 270 func BenchmarkMutexSlack(b *testing.B) {
 271         benchmarkMutex(b, true, false)
 272 }
 273
 274 func BenchmarkMutexWork(b *testing.B) {
 275         benchmarkMutex(b, false, true)
 276 }
 277
 278 func BenchmarkMutexWorkSlack(b *testing.B) {
 279         benchmarkMutex(b, true, true)
 280 }
 281
 282 func BenchmarkMutexNoSpin(b *testing.B) {
 283         // This benchmark models a situation where spinning in the mutex should be
 284         // non-profitable and allows to confirm that spinning does not do harm.
 285         // To achieve this we create excess of goroutines most of which do local work.
 286         // These goroutines yield during local work, so that switching from
 287         // a blocked goroutine to other goroutines is profitable.
 288         // As a matter of fact, this benchmark still triggers some spinning in the mutex.
 289         var m Mutex
 290         var acc0, acc1 uint64
 291         b.SetParallelism(4)
 292         b.RunParallel(func(pb *testing.PB) {
 293                 c := make(chan bool)
 294                 var data [4 << 10]uint64
 295                 for i := 0; pb.Next(); i++ {
 296                         if i%4 == 0 {
 297                                 m.Lock()
 298                                 acc0 -= 100
 299                                 acc1 += 100
 300                                 m.Unlock()
 301                         } else {
 302                                 for i := 0; i < len(data); i += 4 {
 303                                         data[i]++
 304                                 }
 305                                 // Elaborate way to say runtime.Gosched
 306                                 // that does not put the goroutine onto global runq.
 307                                 go func() {
 308                                         c <- true
 309                                 }()
 310                                 <-c
 311                         }
 312                 }
 313         })
 314 }
 315
 316 func BenchmarkMutexSpin(b *testing.B) {
 317         // This benchmark models a situation where spinning in the mutex should be
 318         // profitable. To achieve this we create a goroutine per-proc.
 319         // These goroutines access considerable amount of local data so that
 320         // unnecessary rescheduling is penalized by cache misses.
 321         var m Mutex
 322         var acc0, acc1 uint64
 323         b.RunParallel(func(pb *testing.PB) {
 324                 var data [16 << 10]uint64
 325                 for i := 0; pb.Next(); i++ {
 326                         m.Lock()
 327                         acc0 -= 100
 328                         acc1 += 100
 329                         m.Unlock()
 330                         for i := 0; i < len(data); i += 4 {
 331                                 data[i]++
 332                         }
 333                 }
 334         })
 335 }