rwmutex_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  	"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  	var m RWMutex
   112  
   113  	m.Lock()
   114  	if m.TryLock() {
   115  		t.Fatalf("TryLock succeeded with mutex locked")
   116  	}
   117  	if m.TryRLock() {
   118  		t.Fatalf("TryRLock succeeded with mutex locked")
   119  	}
   120  	m.Unlock()
   121  
   122  	if !m.TryLock() {
   123  		t.Fatalf("TryLock failed with mutex unlocked")
   124  	}
   125  	m.Unlock()
   126  
   127  	if !m.TryRLock() {
   128  		t.Fatalf("TryRLock failed with mutex unlocked")
   129  	}
   130  	if !m.TryRLock() {
   131  		t.Fatalf("TryRLock failed with mutex rlocked")
   132  	}
   133  	if m.TryLock() {
   134  		t.Fatalf("TryLock succeeded with mutex rlocked")
   135  	}
   136  	m.RUnlock()
   137  	m.RUnlock()
   138  
   139  	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(-1))
   140  	n := 1000
   141  	if testing.Short() {
   142  		n = 5
   143  	}
   144  	HammerRWMutex(1, 1, n)
   145  	HammerRWMutex(1, 3, n)
   146  	HammerRWMutex(1, 10, n)
   147  	HammerRWMutex(4, 1, n)
   148  	HammerRWMutex(4, 3, n)
   149  	HammerRWMutex(4, 10, n)
   150  	HammerRWMutex(10, 1, n)
   151  	HammerRWMutex(10, 3, n)
   152  	HammerRWMutex(10, 10, n)
   153  	HammerRWMutex(10, 5, n)
   154  }
   155  
   156  func TestRLocker(t *testing.T) {
   157  	var wl RWMutex
   158  	var rl Locker
   159  	wlocked := make(chan bool, 1)
   160  	rlocked := make(chan bool, 1)
   161  	rl = wl.RLocker()
   162  	n := 10
   163  	go func() {
   164  		for i := 0; i < n; i++ {
   165  			rl.Lock()
   166  			rl.Lock()
   167  			rlocked <- true
   168  			wl.Lock()
   169  			wlocked <- true
   170  		}
   171  	}()
   172  	for i := 0; i < n; i++ {
   173  		<-rlocked
   174  		rl.Unlock()
   175  		select {
   176  		case <-wlocked:
   177  			t.Fatal("RLocker() didn't read-lock it")
   178  		default:
   179  		}
   180  		rl.Unlock()
   181  		<-wlocked
   182  		select {
   183  		case <-rlocked:
   184  			t.Fatal("RLocker() didn't respect the write lock")
   185  		default:
   186  		}
   187  		wl.Unlock()
   188  	}
   189  }
   190  
   191  func BenchmarkRWMutexUncontended(b *testing.B) {
   192  	type PaddedRWMutex struct {
   193  		RWMutex
   194  		pad [32]uint32
   195  	}
   196  	b.RunParallel(func(pb *testing.PB) {
   197  		var rwm PaddedRWMutex
   198  		for pb.Next() {
   199  			rwm.RLock()
   200  			rwm.RLock()
   201  			rwm.RUnlock()
   202  			rwm.RUnlock()
   203  			rwm.Lock()
   204  			rwm.Unlock()
   205  		}
   206  	})
   207  }
   208  
   209  func benchmarkRWMutex(b *testing.B, localWork, writeRatio int) {
   210  	var rwm RWMutex
   211  	b.RunParallel(func(pb *testing.PB) {
   212  		foo := 0
   213  		for pb.Next() {
   214  			foo++
   215  			if foo%writeRatio == 0 {
   216  				rwm.Lock()
   217  				rwm.Unlock()
   218  			} else {
   219  				rwm.RLock()
   220  				for i := 0; i != localWork; i += 1 {
   221  					foo *= 2
   222  					foo /= 2
   223  				}
   224  				rwm.RUnlock()
   225  			}
   226  		}
   227  		_ = foo
   228  	})
   229  }
   230  
   231  func BenchmarkRWMutexWrite100(b *testing.B) {
   232  	benchmarkRWMutex(b, 0, 100)
   233  }
   234  
   235  func BenchmarkRWMutexWrite10(b *testing.B) {
   236  	benchmarkRWMutex(b, 0, 10)
   237  }
   238  
   239  func BenchmarkRWMutexWorkWrite100(b *testing.B) {
   240  	benchmarkRWMutex(b, 100, 100)
   241  }
   242  
   243  func BenchmarkRWMutexWorkWrite10(b *testing.B) {
   244  	benchmarkRWMutex(b, 100, 10)
   245  }
   246
View as plain text