...
Run Format

Source file src/runtime/rwmutex_test.go

Documentation: runtime

     1  // Copyright 2017 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  // This is a copy of sync/rwmutex_test.go rewritten to test the
     8  // runtime rwmutex.
     9  
    10  package runtime_test
    11  
    12  import (
    13  	"fmt"
    14  	. "runtime"
    15  	"runtime/debug"
    16  	"sync/atomic"
    17  	"testing"
    18  )
    19  
    20  func parallelReader(m *RWMutex, clocked chan bool, cunlock *uint32, cdone chan bool) {
    21  	m.RLock()
    22  	clocked <- true
    23  	for atomic.LoadUint32(cunlock) == 0 {
    24  	}
    25  	m.RUnlock()
    26  	cdone <- true
    27  }
    28  
    29  func doTestParallelReaders(numReaders int) {
    30  	GOMAXPROCS(numReaders + 1)
    31  	var m RWMutex
    32  	clocked := make(chan bool, numReaders)
    33  	var cunlock uint32
    34  	cdone := make(chan bool)
    35  	for i := 0; i < numReaders; i++ {
    36  		go parallelReader(&m, clocked, &cunlock, cdone)
    37  	}
    38  	// Wait for all parallel RLock()s to succeed.
    39  	for i := 0; i < numReaders; i++ {
    40  		<-clocked
    41  	}
    42  	atomic.StoreUint32(&cunlock, 1)
    43  	// Wait for the goroutines to finish.
    44  	for i := 0; i < numReaders; i++ {
    45  		<-cdone
    46  	}
    47  }
    48  
    49  func TestParallelRWMutexReaders(t *testing.T) {
    50  	if GOARCH == "wasm" {
    51  		t.Skip("wasm has no threads yet")
    52  	}
    53  	defer GOMAXPROCS(GOMAXPROCS(-1))
    54  	// If runtime triggers a forced GC during this test then it will deadlock,
    55  	// since the goroutines can't be stopped/preempted.
    56  	// Disable GC for this test (see issue #10958).
    57  	defer debug.SetGCPercent(debug.SetGCPercent(-1))
    58  	doTestParallelReaders(1)
    59  	doTestParallelReaders(3)
    60  	doTestParallelReaders(4)
    61  }
    62  
    63  func reader(rwm *RWMutex, num_iterations int, activity *int32, cdone chan bool) {
    64  	for i := 0; i < num_iterations; i++ {
    65  		rwm.RLock()
    66  		n := atomic.AddInt32(activity, 1)
    67  		if n < 1 || n >= 10000 {
    68  			panic(fmt.Sprintf("wlock(%d)\n", n))
    69  		}
    70  		for i := 0; i < 100; i++ {
    71  		}
    72  		atomic.AddInt32(activity, -1)
    73  		rwm.RUnlock()
    74  	}
    75  	cdone <- true
    76  }
    77  
    78  func writer(rwm *RWMutex, num_iterations int, activity *int32, cdone chan bool) {
    79  	for i := 0; i < num_iterations; i++ {
    80  		rwm.Lock()
    81  		n := atomic.AddInt32(activity, 10000)
    82  		if n != 10000 {
    83  			panic(fmt.Sprintf("wlock(%d)\n", n))
    84  		}
    85  		for i := 0; i < 100; i++ {
    86  		}
    87  		atomic.AddInt32(activity, -10000)
    88  		rwm.Unlock()
    89  	}
    90  	cdone <- true
    91  }
    92  
    93  func HammerRWMutex(gomaxprocs, numReaders, num_iterations int) {
    94  	GOMAXPROCS(gomaxprocs)
    95  	// Number of active readers + 10000 * number of active writers.
    96  	var activity int32
    97  	var rwm RWMutex
    98  	cdone := make(chan bool)
    99  	go writer(&rwm, num_iterations, &activity, cdone)
   100  	var i int
   101  	for i = 0; i < numReaders/2; i++ {
   102  		go reader(&rwm, num_iterations, &activity, cdone)
   103  	}
   104  	go writer(&rwm, num_iterations, &activity, cdone)
   105  	for ; i < numReaders; i++ {
   106  		go reader(&rwm, num_iterations, &activity, cdone)
   107  	}
   108  	// Wait for the 2 writers and all readers to finish.
   109  	for i := 0; i < 2+numReaders; i++ {
   110  		<-cdone
   111  	}
   112  }
   113  
   114  func TestRWMutex(t *testing.T) {
   115  	defer GOMAXPROCS(GOMAXPROCS(-1))
   116  	n := 1000
   117  	if testing.Short() {
   118  		n = 5
   119  	}
   120  	HammerRWMutex(1, 1, n)
   121  	HammerRWMutex(1, 3, n)
   122  	HammerRWMutex(1, 10, n)
   123  	HammerRWMutex(4, 1, n)
   124  	HammerRWMutex(4, 3, n)
   125  	HammerRWMutex(4, 10, n)
   126  	HammerRWMutex(10, 1, n)
   127  	HammerRWMutex(10, 3, n)
   128  	HammerRWMutex(10, 10, n)
   129  	HammerRWMutex(10, 5, n)
   130  }
   131  
   132  func BenchmarkRWMutexUncontended(b *testing.B) {
   133  	type PaddedRWMutex struct {
   134  		RWMutex
   135  		pad [32]uint32
   136  	}
   137  	b.RunParallel(func(pb *testing.PB) {
   138  		var rwm PaddedRWMutex
   139  		for pb.Next() {
   140  			rwm.RLock()
   141  			rwm.RLock()
   142  			rwm.RUnlock()
   143  			rwm.RUnlock()
   144  			rwm.Lock()
   145  			rwm.Unlock()
   146  		}
   147  	})
   148  }
   149  
   150  func benchmarkRWMutex(b *testing.B, localWork, writeRatio int) {
   151  	var rwm RWMutex
   152  	b.RunParallel(func(pb *testing.PB) {
   153  		foo := 0
   154  		for pb.Next() {
   155  			foo++
   156  			if foo%writeRatio == 0 {
   157  				rwm.Lock()
   158  				rwm.Unlock()
   159  			} else {
   160  				rwm.RLock()
   161  				for i := 0; i != localWork; i += 1 {
   162  					foo *= 2
   163  					foo /= 2
   164  				}
   165  				rwm.RUnlock()
   166  			}
   167  		}
   168  		_ = foo
   169  	})
   170  }
   171  
   172  func BenchmarkRWMutexWrite100(b *testing.B) {
   173  	benchmarkRWMutex(b, 0, 100)
   174  }
   175  
   176  func BenchmarkRWMutexWrite10(b *testing.B) {
   177  	benchmarkRWMutex(b, 0, 10)
   178  }
   179  
   180  func BenchmarkRWMutexWorkWrite100(b *testing.B) {
   181  	benchmarkRWMutex(b, 100, 100)
   182  }
   183  
   184  func BenchmarkRWMutexWorkWrite10(b *testing.B) {
   185  	benchmarkRWMutex(b, 100, 10)
   186  }
   187  

View as plain text