mutex_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  	"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  		m.Lock()
    64  		m.Unlock()
    65  	}
    66  	cdone <- true
    67  }
    68  
    69  func TestMutex(t *testing.T) {
    70  	if n := runtime.SetMutexProfileFraction(1); n != 0 {
    71  		t.Logf("got mutexrate %d expected 0", n)
    72  	}
    73  	defer runtime.SetMutexProfileFraction(0)
    74  	m := new(Mutex)
    75  	c := make(chan bool)
    76  	for i := 0; i < 10; i++ {
    77  		go HammerMutex(m, 1000, c)
    78  	}
    79  	for i := 0; i < 10; i++ {
    80  		<-c
    81  	}
    82  }
    83  
    84  var misuseTests = []struct {
    85  	name string
    86  	f    func()
    87  }{
    88  	{
    89  		"Mutex.Unlock",
    90  		func() {
    91  			var mu Mutex
    92  			mu.Unlock()
    93  		},
    94  	},
    95  	{
    96  		"Mutex.Unlock2",
    97  		func() {
    98  			var mu Mutex
    99  			mu.Lock()
   100  			mu.Unlock()
   101  			mu.Unlock()
   102  		},
   103  	},
   104  	{
   105  		"RWMutex.Unlock",
   106  		func() {
   107  			var mu RWMutex
   108  			mu.Unlock()
   109  		},
   110  	},
   111  	{
   112  		"RWMutex.Unlock2",
   113  		func() {
   114  			var mu RWMutex
   115  			mu.RLock()
   116  			mu.Unlock()
   117  		},
   118  	},
   119  	{
   120  		"RWMutex.Unlock3",
   121  		func() {
   122  			var mu RWMutex
   123  			mu.Lock()
   124  			mu.Unlock()
   125  			mu.Unlock()
   126  		},
   127  	},
   128  	{
   129  		"RWMutex.RUnlock",
   130  		func() {
   131  			var mu RWMutex
   132  			mu.RUnlock()
   133  		},
   134  	},
   135  	{
   136  		"RWMutex.RUnlock2",
   137  		func() {
   138  			var mu RWMutex
   139  			mu.Lock()
   140  			mu.RUnlock()
   141  		},
   142  	},
   143  	{
   144  		"RWMutex.RUnlock3",
   145  		func() {
   146  			var mu RWMutex
   147  			mu.RLock()
   148  			mu.RUnlock()
   149  			mu.RUnlock()
   150  		},
   151  	},
   152  }
   153  
   154  func init() {
   155  	if len(os.Args) == 3 && os.Args[1] == "TESTMISUSE" {
   156  		for _, test := range misuseTests {
   157  			if test.name == os.Args[2] {
   158  				func() {
   159  					defer func() { recover() }()
   160  					test.f()
   161  				}()
   162  				fmt.Printf("test completed\n")
   163  				os.Exit(0)
   164  			}
   165  		}
   166  		fmt.Printf("unknown test\n")
   167  		os.Exit(0)
   168  	}
   169  }
   170  
   171  func TestMutexMisuse(t *testing.T) {
   172  	testenv.MustHaveExec(t)
   173  	for _, test := range misuseTests {
   174  		out, err := exec.Command(os.Args[0], "TESTMISUSE", test.name).CombinedOutput()
   175  		if err == nil || !strings.Contains(string(out), "unlocked") {
   176  			t.Errorf("%s: did not find failure with message about unlocked lock: %s\n%s\n", test.name, err, out)
   177  		}
   178  	}
   179  }
   180  
   181  func TestMutexFairness(t *testing.T) {
   182  	var mu Mutex
   183  	stop := make(chan bool)
   184  	defer close(stop)
   185  	go func() {
   186  		for {
   187  			mu.Lock()
   188  			time.Sleep(100 * time.Microsecond)
   189  			mu.Unlock()
   190  			select {
   191  			case <-stop:
   192  				return
   193  			default:
   194  			}
   195  		}
   196  	}()
   197  	done := make(chan bool, 1)
   198  	go func() {
   199  		for i := 0; i < 10; i++ {
   200  			time.Sleep(100 * time.Microsecond)
   201  			mu.Lock()
   202  			mu.Unlock()
   203  		}
   204  		done <- true
   205  	}()
   206  	select {
   207  	case <-done:
   208  	case <-time.After(10 * time.Second):
   209  		t.Fatalf("can't acquire Mutex in 10 seconds")
   210  	}
   211  }
   212  
   213  func BenchmarkMutexUncontended(b *testing.B) {
   214  	type PaddedMutex struct {
   215  		Mutex
   216  		pad [128]uint8
   217  	}
   218  	b.RunParallel(func(pb *testing.PB) {
   219  		var mu PaddedMutex
   220  		for pb.Next() {
   221  			mu.Lock()
   222  			mu.Unlock()
   223  		}
   224  	})
   225  }
   226  
   227  func benchmarkMutex(b *testing.B, slack, work bool) {
   228  	var mu Mutex
   229  	if slack {
   230  		b.SetParallelism(10)
   231  	}
   232  	b.RunParallel(func(pb *testing.PB) {
   233  		foo := 0
   234  		for pb.Next() {
   235  			mu.Lock()
   236  			mu.Unlock()
   237  			if work {
   238  				for i := 0; i < 100; i++ {
   239  					foo *= 2
   240  					foo /= 2
   241  				}
   242  			}
   243  		}
   244  		_ = foo
   245  	})
   246  }
   247  
   248  func BenchmarkMutex(b *testing.B) {
   249  	benchmarkMutex(b, false, false)
   250  }
   251  
   252  func BenchmarkMutexSlack(b *testing.B) {
   253  	benchmarkMutex(b, true, false)
   254  }
   255  
   256  func BenchmarkMutexWork(b *testing.B) {
   257  	benchmarkMutex(b, false, true)
   258  }
   259  
   260  func BenchmarkMutexWorkSlack(b *testing.B) {
   261  	benchmarkMutex(b, true, true)
   262  }
   263  
   264  func BenchmarkMutexNoSpin(b *testing.B) {
   265  	// This benchmark models a situation where spinning in the mutex should be
   266  	// non-profitable and allows to confirm that spinning does not do harm.
   267  	// To achieve this we create excess of goroutines most of which do local work.
   268  	// These goroutines yield during local work, so that switching from
   269  	// a blocked goroutine to other goroutines is profitable.
   270  	// As a matter of fact, this benchmark still triggers some spinning in the mutex.
   271  	var m Mutex
   272  	var acc0, acc1 uint64
   273  	b.SetParallelism(4)
   274  	b.RunParallel(func(pb *testing.PB) {
   275  		c := make(chan bool)
   276  		var data [4 << 10]uint64
   277  		for i := 0; pb.Next(); i++ {
   278  			if i%4 == 0 {
   279  				m.Lock()
   280  				acc0 -= 100
   281  				acc1 += 100
   282  				m.Unlock()
   283  			} else {
   284  				for i := 0; i < len(data); i += 4 {
   285  					data[i]++
   286  				}
   287  				// Elaborate way to say runtime.Gosched
   288  				// that does not put the goroutine onto global runq.
   289  				go func() {
   290  					c <- true
   291  				}()
   292  				<-c
   293  			}
   294  		}
   295  	})
   296  }
   297  
   298  func BenchmarkMutexSpin(b *testing.B) {
   299  	// This benchmark models a situation where spinning in the mutex should be
   300  	// profitable. To achieve this we create a goroutine per-proc.
   301  	// These goroutines access considerable amount of local data so that
   302  	// unnecessary rescheduling is penalized by cache misses.
   303  	var m Mutex
   304  	var acc0, acc1 uint64
   305  	b.RunParallel(func(pb *testing.PB) {
   306  		var data [16 << 10]uint64
   307  		for i := 0; pb.Next(); i++ {
   308  			m.Lock()
   309  			acc0 -= 100
   310  			acc1 += 100
   311  			m.Unlock()
   312  			for i := 0; i < len(data); i += 4 {
   313  				data[i]++
   314  			}
   315  		}
   316  	})
   317  }
   318
View as plain text