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 "runtime" 12 . "sync" 13 "sync/atomic" 14 "testing" 15 ) 16 17 // There is a modified copy of this file in runtime/rwmutex_test.go. 18 // If you make any changes here, see if you should make them there. 19 20 func parallelReader(m *RWMutex, clocked, cunlock, cdone chan bool) { 21 m.RLock() 22 clocked <- true 23 <-cunlock 24 m.RUnlock() 25 cdone <- true 26 } 27 28 func doTestParallelReaders(numReaders, gomaxprocs int) { 29 runtime.GOMAXPROCS(gomaxprocs) 30 var m RWMutex 31 clocked := make(chan bool) 32 cunlock := make(chan bool) 33 cdone := make(chan bool) 34 for i := 0; i < numReaders; i++ { 35 go parallelReader(&m, clocked, cunlock, cdone) 36 } 37 // Wait for all parallel RLock()s to succeed. 38 for i := 0; i < numReaders; i++ { 39 <-clocked 40 } 41 for i := 0; i < numReaders; i++ { 42 cunlock <- true 43 } 44 // Wait for the goroutines to finish. 45 for i := 0; i < numReaders; i++ { 46 <-cdone 47 } 48 } 49 50 func TestParallelReaders(t *testing.T) { 51 defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(-1)) 52 doTestParallelReaders(1, 4) 53 doTestParallelReaders(3, 4) 54 doTestParallelReaders(4, 2) 55 } 56 57 func reader(rwm *RWMutex, num_iterations int, activity *int32, cdone chan bool) { 58 for i := 0; i < num_iterations; i++ { 59 rwm.RLock() 60 n := atomic.AddInt32(activity, 1) 61 if n < 1 || n >= 10000 { 62 panic(fmt.Sprintf("wlock(%d)\n", n)) 63 } 64 for i := 0; i < 100; i++ { 65 } 66 atomic.AddInt32(activity, -1) 67 rwm.RUnlock() 68 } 69 cdone <- true 70 } 71 72 func writer(rwm *RWMutex, num_iterations int, activity *int32, cdone chan bool) { 73 for i := 0; i < num_iterations; i++ { 74 rwm.Lock() 75 n := atomic.AddInt32(activity, 10000) 76 if n != 10000 { 77 panic(fmt.Sprintf("wlock(%d)\n", n)) 78 } 79 for i := 0; i < 100; i++ { 80 } 81 atomic.AddInt32(activity, -10000) 82 rwm.Unlock() 83 } 84 cdone <- true 85 } 86 87 func HammerRWMutex(gomaxprocs, numReaders, num_iterations int) { 88 runtime.GOMAXPROCS(gomaxprocs) 89 // Number of active readers + 10000 * number of active writers. 90 var activity int32 91 var rwm RWMutex 92 cdone := make(chan bool) 93 go writer(&rwm, num_iterations, &activity, cdone) 94 var i int 95 for i = 0; i < numReaders/2; i++ { 96 go reader(&rwm, num_iterations, &activity, cdone) 97 } 98 go writer(&rwm, num_iterations, &activity, cdone) 99 for ; i < numReaders; i++ { 100 go reader(&rwm, num_iterations, &activity, cdone) 101 } 102 // Wait for the 2 writers and all readers to finish. 103 for i := 0; i < 2+numReaders; i++ { 104 <-cdone 105 } 106 } 107 108 func TestRWMutex(t *testing.T) { 109 defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(-1)) 110 n := 1000 111 if testing.Short() { 112 n = 5 113 } 114 HammerRWMutex(1, 1, n) 115 HammerRWMutex(1, 3, n) 116 HammerRWMutex(1, 10, n) 117 HammerRWMutex(4, 1, n) 118 HammerRWMutex(4, 3, n) 119 HammerRWMutex(4, 10, n) 120 HammerRWMutex(10, 1, n) 121 HammerRWMutex(10, 3, n) 122 HammerRWMutex(10, 10, n) 123 HammerRWMutex(10, 5, n) 124 } 125 126 func TestRLocker(t *testing.T) { 127 var wl RWMutex 128 var rl Locker 129 wlocked := make(chan bool, 1) 130 rlocked := make(chan bool, 1) 131 rl = wl.RLocker() 132 n := 10 133 go func() { 134 for i := 0; i < n; i++ { 135 rl.Lock() 136 rl.Lock() 137 rlocked <- true 138 wl.Lock() 139 wlocked <- true 140 } 141 }() 142 for i := 0; i < n; i++ { 143 <-rlocked 144 rl.Unlock() 145 select { 146 case <-wlocked: 147 t.Fatal("RLocker() didn't read-lock it") 148 default: 149 } 150 rl.Unlock() 151 <-wlocked 152 select { 153 case <-rlocked: 154 t.Fatal("RLocker() didn't respect the write lock") 155 default: 156 } 157 wl.Unlock() 158 } 159 } 160 161 func BenchmarkRWMutexUncontended(b *testing.B) { 162 type PaddedRWMutex struct { 163 RWMutex 164 pad [32]uint32 165 } 166 b.RunParallel(func(pb *testing.PB) { 167 var rwm PaddedRWMutex 168 for pb.Next() { 169 rwm.RLock() 170 rwm.RLock() 171 rwm.RUnlock() 172 rwm.RUnlock() 173 rwm.Lock() 174 rwm.Unlock() 175 } 176 }) 177 } 178 179 func benchmarkRWMutex(b *testing.B, localWork, writeRatio int) { 180 var rwm RWMutex 181 b.RunParallel(func(pb *testing.PB) { 182 foo := 0 183 for pb.Next() { 184 foo++ 185 if foo%writeRatio == 0 { 186 rwm.Lock() 187 rwm.Unlock() 188 } else { 189 rwm.RLock() 190 for i := 0; i != localWork; i += 1 { 191 foo *= 2 192 foo /= 2 193 } 194 rwm.RUnlock() 195 } 196 } 197 _ = foo 198 }) 199 } 200 201 func BenchmarkRWMutexWrite100(b *testing.B) { 202 benchmarkRWMutex(b, 0, 100) 203 } 204 205 func BenchmarkRWMutexWrite10(b *testing.B) { 206 benchmarkRWMutex(b, 0, 10) 207 } 208 209 func BenchmarkRWMutexWorkWrite100(b *testing.B) { 210 benchmarkRWMutex(b, 100, 100) 211 } 212 213 func BenchmarkRWMutexWorkWrite10(b *testing.B) { 214 benchmarkRWMutex(b, 100, 10) 215 } 216
