rwmutex_test.go

Documentation: sync

		 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  			rwm.RUnlock()
		63  			panic(fmt.Sprintf("wlock(%d)\n", n))
		64  		}
		65  		for i := 0; i < 100; i++ {
		66  		}
		67  		atomic.AddInt32(activity, -1)
		68  		rwm.RUnlock()
		69  	}
		70  	cdone <- true
		71  }
		72  
		73  func writer(rwm *RWMutex, num_iterations int, activity *int32, cdone chan bool) {
		74  	for i := 0; i < num_iterations; i++ {
		75  		rwm.Lock()
		76  		n := atomic.AddInt32(activity, 10000)
		77  		if n != 10000 {
		78  			rwm.Unlock()
		79  			panic(fmt.Sprintf("wlock(%d)\n", n))
		80  		}
		81  		for i := 0; i < 100; i++ {
		82  		}
		83  		atomic.AddInt32(activity, -10000)
		84  		rwm.Unlock()
		85  	}
		86  	cdone <- true
		87  }
		88  
		89  func HammerRWMutex(gomaxprocs, numReaders, num_iterations int) {
		90  	runtime.GOMAXPROCS(gomaxprocs)
		91  	// Number of active readers + 10000 * number of active writers.
		92  	var activity int32
		93  	var rwm RWMutex
		94  	cdone := make(chan bool)
		95  	go writer(&rwm, num_iterations, &activity, cdone)
		96  	var i int
		97  	for i = 0; i < numReaders/2; i++ {
		98  		go reader(&rwm, num_iterations, &activity, cdone)
		99  	}
	 100  	go writer(&rwm, num_iterations, &activity, cdone)
	 101  	for ; i < numReaders; i++ {
	 102  		go reader(&rwm, num_iterations, &activity, cdone)
	 103  	}
	 104  	// Wait for the 2 writers and all readers to finish.
	 105  	for i := 0; i < 2+numReaders; i++ {
	 106  		<-cdone
	 107  	}
	 108  }
	 109  
	 110  func TestRWMutex(t *testing.T) {
	 111  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(-1))
	 112  	n := 1000
	 113  	if testing.Short() {
	 114  		n = 5
	 115  	}
	 116  	HammerRWMutex(1, 1, n)
	 117  	HammerRWMutex(1, 3, n)
	 118  	HammerRWMutex(1, 10, n)
	 119  	HammerRWMutex(4, 1, n)
	 120  	HammerRWMutex(4, 3, n)
	 121  	HammerRWMutex(4, 10, n)
	 122  	HammerRWMutex(10, 1, n)
	 123  	HammerRWMutex(10, 3, n)
	 124  	HammerRWMutex(10, 10, n)
	 125  	HammerRWMutex(10, 5, n)
	 126  }
	 127  
	 128  func TestRLocker(t *testing.T) {
	 129  	var wl RWMutex
	 130  	var rl Locker
	 131  	wlocked := make(chan bool, 1)
	 132  	rlocked := make(chan bool, 1)
	 133  	rl = wl.RLocker()
	 134  	n := 10
	 135  	go func() {
	 136  		for i := 0; i < n; i++ {
	 137  			rl.Lock()
	 138  			rl.Lock()
	 139  			rlocked <- true
	 140  			wl.Lock()
	 141  			wlocked <- true
	 142  		}
	 143  	}()
	 144  	for i := 0; i < n; i++ {
	 145  		<-rlocked
	 146  		rl.Unlock()
	 147  		select {
	 148  		case <-wlocked:
	 149  			t.Fatal("RLocker() didn't read-lock it")
	 150  		default:
	 151  		}
	 152  		rl.Unlock()
	 153  		<-wlocked
	 154  		select {
	 155  		case <-rlocked:
	 156  			t.Fatal("RLocker() didn't respect the write lock")
	 157  		default:
	 158  		}
	 159  		wl.Unlock()
	 160  	}
	 161  }
	 162  
	 163  func BenchmarkRWMutexUncontended(b *testing.B) {
	 164  	type PaddedRWMutex struct {
	 165  		RWMutex
	 166  		pad [32]uint32
	 167  	}
	 168  	b.RunParallel(func(pb *testing.PB) {
	 169  		var rwm PaddedRWMutex
	 170  		for pb.Next() {
	 171  			rwm.RLock()
	 172  			rwm.RLock()
	 173  			rwm.RUnlock()
	 174  			rwm.RUnlock()
	 175  			rwm.Lock()
	 176  			rwm.Unlock()
	 177  		}
	 178  	})
	 179  }
	 180  
	 181  func benchmarkRWMutex(b *testing.B, localWork, writeRatio int) {
	 182  	var rwm RWMutex
	 183  	b.RunParallel(func(pb *testing.PB) {
	 184  		foo := 0
	 185  		for pb.Next() {
	 186  			foo++
	 187  			if foo%writeRatio == 0 {
	 188  				rwm.Lock()
	 189  				rwm.Unlock()
	 190  			} else {
	 191  				rwm.RLock()
	 192  				for i := 0; i != localWork; i += 1 {
	 193  					foo *= 2
	 194  					foo /= 2
	 195  				}
	 196  				rwm.RUnlock()
	 197  			}
	 198  		}
	 199  		_ = foo
	 200  	})
	 201  }
	 202  
	 203  func BenchmarkRWMutexWrite100(b *testing.B) {
	 204  	benchmarkRWMutex(b, 0, 100)
	 205  }
	 206  
	 207  func BenchmarkRWMutexWrite10(b *testing.B) {
	 208  	benchmarkRWMutex(b, 0, 10)
	 209  }
	 210  
	 211  func BenchmarkRWMutexWorkWrite100(b *testing.B) {
	 212  	benchmarkRWMutex(b, 100, 100)
	 213  }
	 214  
	 215  func BenchmarkRWMutexWorkWrite10(b *testing.B) {
	 216  	benchmarkRWMutex(b, 100, 10)
	 217  }
	 218
View as plain text