cond_test.go

Documentation: sync

		 1  // Copyright 2011 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  package sync_test
		 6  
		 7  import (
		 8  	"reflect"
		 9  	"runtime"
		10  	. "sync"
		11  	"testing"
		12  	"time"
		13  )
		14  
		15  func TestCondSignal(t *testing.T) {
		16  	var m Mutex
		17  	c := NewCond(&m)
		18  	n := 2
		19  	running := make(chan bool, n)
		20  	awake := make(chan bool, n)
		21  	for i := 0; i < n; i++ {
		22  		go func() {
		23  			m.Lock()
		24  			running <- true
		25  			c.Wait()
		26  			awake <- true
		27  			m.Unlock()
		28  		}()
		29  	}
		30  	for i := 0; i < n; i++ {
		31  		<-running // Wait for everyone to run.
		32  	}
		33  	for n > 0 {
		34  		select {
		35  		case <-awake:
		36  			t.Fatal("goroutine not asleep")
		37  		default:
		38  		}
		39  		m.Lock()
		40  		c.Signal()
		41  		m.Unlock()
		42  		<-awake // Will deadlock if no goroutine wakes up
		43  		select {
		44  		case <-awake:
		45  			t.Fatal("too many goroutines awake")
		46  		default:
		47  		}
		48  		n--
		49  	}
		50  	c.Signal()
		51  }
		52  
		53  func TestCondSignalGenerations(t *testing.T) {
		54  	var m Mutex
		55  	c := NewCond(&m)
		56  	n := 100
		57  	running := make(chan bool, n)
		58  	awake := make(chan int, n)
		59  	for i := 0; i < n; i++ {
		60  		go func(i int) {
		61  			m.Lock()
		62  			running <- true
		63  			c.Wait()
		64  			awake <- i
		65  			m.Unlock()
		66  		}(i)
		67  		if i > 0 {
		68  			a := <-awake
		69  			if a != i-1 {
		70  				t.Fatalf("wrong goroutine woke up: want %d, got %d", i-1, a)
		71  			}
		72  		}
		73  		<-running
		74  		m.Lock()
		75  		c.Signal()
		76  		m.Unlock()
		77  	}
		78  }
		79  
		80  func TestCondBroadcast(t *testing.T) {
		81  	var m Mutex
		82  	c := NewCond(&m)
		83  	n := 200
		84  	running := make(chan int, n)
		85  	awake := make(chan int, n)
		86  	exit := false
		87  	for i := 0; i < n; i++ {
		88  		go func(g int) {
		89  			m.Lock()
		90  			for !exit {
		91  				running <- g
		92  				c.Wait()
		93  				awake <- g
		94  			}
		95  			m.Unlock()
		96  		}(i)
		97  	}
		98  	for i := 0; i < n; i++ {
		99  		for i := 0; i < n; i++ {
	 100  			<-running // Will deadlock unless n are running.
	 101  		}
	 102  		if i == n-1 {
	 103  			m.Lock()
	 104  			exit = true
	 105  			m.Unlock()
	 106  		}
	 107  		select {
	 108  		case <-awake:
	 109  			t.Fatal("goroutine not asleep")
	 110  		default:
	 111  		}
	 112  		m.Lock()
	 113  		c.Broadcast()
	 114  		m.Unlock()
	 115  		seen := make([]bool, n)
	 116  		for i := 0; i < n; i++ {
	 117  			g := <-awake
	 118  			if seen[g] {
	 119  				t.Fatal("goroutine woke up twice")
	 120  			}
	 121  			seen[g] = true
	 122  		}
	 123  	}
	 124  	select {
	 125  	case <-running:
	 126  		t.Fatal("goroutine did not exit")
	 127  	default:
	 128  	}
	 129  	c.Broadcast()
	 130  }
	 131  
	 132  func TestRace(t *testing.T) {
	 133  	x := 0
	 134  	c := NewCond(&Mutex{})
	 135  	done := make(chan bool)
	 136  	go func() {
	 137  		c.L.Lock()
	 138  		x = 1
	 139  		c.Wait()
	 140  		if x != 2 {
	 141  			t.Error("want 2")
	 142  		}
	 143  		x = 3
	 144  		c.Signal()
	 145  		c.L.Unlock()
	 146  		done <- true
	 147  	}()
	 148  	go func() {
	 149  		c.L.Lock()
	 150  		for {
	 151  			if x == 1 {
	 152  				x = 2
	 153  				c.Signal()
	 154  				break
	 155  			}
	 156  			c.L.Unlock()
	 157  			runtime.Gosched()
	 158  			c.L.Lock()
	 159  		}
	 160  		c.L.Unlock()
	 161  		done <- true
	 162  	}()
	 163  	go func() {
	 164  		c.L.Lock()
	 165  		for {
	 166  			if x == 2 {
	 167  				c.Wait()
	 168  				if x != 3 {
	 169  					t.Error("want 3")
	 170  				}
	 171  				break
	 172  			}
	 173  			if x == 3 {
	 174  				break
	 175  			}
	 176  			c.L.Unlock()
	 177  			runtime.Gosched()
	 178  			c.L.Lock()
	 179  		}
	 180  		c.L.Unlock()
	 181  		done <- true
	 182  	}()
	 183  	<-done
	 184  	<-done
	 185  	<-done
	 186  }
	 187  
	 188  func TestCondSignalStealing(t *testing.T) {
	 189  	for iters := 0; iters < 1000; iters++ {
	 190  		var m Mutex
	 191  		cond := NewCond(&m)
	 192  
	 193  		// Start a waiter.
	 194  		ch := make(chan struct{})
	 195  		go func() {
	 196  			m.Lock()
	 197  			ch <- struct{}{}
	 198  			cond.Wait()
	 199  			m.Unlock()
	 200  
	 201  			ch <- struct{}{}
	 202  		}()
	 203  
	 204  		<-ch
	 205  		m.Lock()
	 206  		m.Unlock()
	 207  
	 208  		// We know that the waiter is in the cond.Wait() call because we
	 209  		// synchronized with it, then acquired/released the mutex it was
	 210  		// holding when we synchronized.
	 211  		//
	 212  		// Start two goroutines that will race: one will broadcast on
	 213  		// the cond var, the other will wait on it.
	 214  		//
	 215  		// The new waiter may or may not get notified, but the first one
	 216  		// has to be notified.
	 217  		done := false
	 218  		go func() {
	 219  			cond.Broadcast()
	 220  		}()
	 221  
	 222  		go func() {
	 223  			m.Lock()
	 224  			for !done {
	 225  				cond.Wait()
	 226  			}
	 227  			m.Unlock()
	 228  		}()
	 229  
	 230  		// Check that the first waiter does get signaled.
	 231  		select {
	 232  		case <-ch:
	 233  		case <-time.After(2 * time.Second):
	 234  			t.Fatalf("First waiter didn't get broadcast.")
	 235  		}
	 236  
	 237  		// Release the second waiter in case it didn't get the
	 238  		// broadcast.
	 239  		m.Lock()
	 240  		done = true
	 241  		m.Unlock()
	 242  		cond.Broadcast()
	 243  	}
	 244  }
	 245  
	 246  func TestCondCopy(t *testing.T) {
	 247  	defer func() {
	 248  		err := recover()
	 249  		if err == nil || err.(string) != "sync.Cond is copied" {
	 250  			t.Fatalf("got %v, expect sync.Cond is copied", err)
	 251  		}
	 252  	}()
	 253  	c := Cond{L: &Mutex{}}
	 254  	c.Signal()
	 255  	var c2 Cond
	 256  	reflect.ValueOf(&c2).Elem().Set(reflect.ValueOf(&c).Elem()) // c2 := c, hidden from vet
	 257  	c2.Signal()
	 258  }
	 259  
	 260  func BenchmarkCond1(b *testing.B) {
	 261  	benchmarkCond(b, 1)
	 262  }
	 263  
	 264  func BenchmarkCond2(b *testing.B) {
	 265  	benchmarkCond(b, 2)
	 266  }
	 267  
	 268  func BenchmarkCond4(b *testing.B) {
	 269  	benchmarkCond(b, 4)
	 270  }
	 271  
	 272  func BenchmarkCond8(b *testing.B) {
	 273  	benchmarkCond(b, 8)
	 274  }
	 275  
	 276  func BenchmarkCond16(b *testing.B) {
	 277  	benchmarkCond(b, 16)
	 278  }
	 279  
	 280  func BenchmarkCond32(b *testing.B) {
	 281  	benchmarkCond(b, 32)
	 282  }
	 283  
	 284  func benchmarkCond(b *testing.B, waiters int) {
	 285  	c := NewCond(&Mutex{})
	 286  	done := make(chan bool)
	 287  	id := 0
	 288  
	 289  	for routine := 0; routine < waiters+1; routine++ {
	 290  		go func() {
	 291  			for i := 0; i < b.N; i++ {
	 292  				c.L.Lock()
	 293  				if id == -1 {
	 294  					c.L.Unlock()
	 295  					break
	 296  				}
	 297  				id++
	 298  				if id == waiters+1 {
	 299  					id = 0
	 300  					c.Broadcast()
	 301  				} else {
	 302  					c.Wait()
	 303  				}
	 304  				c.L.Unlock()
	 305  			}
	 306  			c.L.Lock()
	 307  			id = -1
	 308  			c.Broadcast()
	 309  			c.L.Unlock()
	 310  			done <- true
	 311  		}()
	 312  	}
	 313  	for routine := 0; routine < waiters+1; routine++ {
	 314  		<-done
	 315  	}
	 316  }
	 317
View as plain text