7a9389330e
gcc/: * gcc.c (default_compilers): Add entry for ".go". * common.opt: Add -static-libgo as a driver option. * doc/install.texi (Configuration): Mention libgo as an option for --enable-shared. Mention go as an option for --enable-languages. * doc/invoke.texi (Overall Options): Mention .go as a file name suffix. Mention go as a -x option. * doc/frontends.texi (G++ and GCC): Mention Go as a supported language. * doc/sourcebuild.texi (Top Level): Mention libgo. * doc/standards.texi (Standards): Add section on Go language. Move references for other languages into their own section. * doc/contrib.texi (Contributors): Mention that I contributed the Go frontend. gcc/testsuite/: * lib/go.exp: New file. * lib/go-dg.exp: New file. * lib/go-torture.exp: New file. * lib/target-supports.exp (check_compile): Match // Go. From-SVN: r167407
115 lines
2.6 KiB
Go
115 lines
2.6 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// GOMAXPROCS=10 gotest
|
|
|
|
package sync_test
|
|
|
|
import (
|
|
"fmt"
|
|
"runtime"
|
|
. "sync"
|
|
"testing"
|
|
)
|
|
|
|
func parallelReader(m *RWMutex, clocked, cunlock, cdone chan bool) {
|
|
m.RLock()
|
|
clocked <- true
|
|
<-cunlock
|
|
m.RUnlock()
|
|
cdone <- true
|
|
}
|
|
|
|
func doTestParallelReaders(numReaders, gomaxprocs int) {
|
|
runtime.GOMAXPROCS(gomaxprocs)
|
|
var m RWMutex
|
|
clocked := make(chan bool)
|
|
cunlock := make(chan bool)
|
|
cdone := make(chan bool)
|
|
for i := 0; i < numReaders; i++ {
|
|
go parallelReader(&m, clocked, cunlock, cdone)
|
|
}
|
|
// Wait for all parallel RLock()s to succeed.
|
|
for i := 0; i < numReaders; i++ {
|
|
<-clocked
|
|
}
|
|
for i := 0; i < numReaders; i++ {
|
|
cunlock <- true
|
|
}
|
|
// Wait for the goroutines to finish.
|
|
for i := 0; i < numReaders; i++ {
|
|
<-cdone
|
|
}
|
|
}
|
|
|
|
func TestParallelReaders(t *testing.T) {
|
|
doTestParallelReaders(1, 4)
|
|
doTestParallelReaders(3, 4)
|
|
doTestParallelReaders(4, 2)
|
|
}
|
|
|
|
func reader(rwm *RWMutex, num_iterations int, activity *uint32, cdone chan bool) {
|
|
for i := 0; i < num_iterations; i++ {
|
|
rwm.RLock()
|
|
n := Xadd(activity, 1)
|
|
if n < 1 || n >= 10000 {
|
|
panic(fmt.Sprintf("wlock(%d)\n", n))
|
|
}
|
|
for i := 0; i < 100; i++ {
|
|
}
|
|
Xadd(activity, -1)
|
|
rwm.RUnlock()
|
|
}
|
|
cdone <- true
|
|
}
|
|
|
|
func writer(rwm *RWMutex, num_iterations int, activity *uint32, cdone chan bool) {
|
|
for i := 0; i < num_iterations; i++ {
|
|
rwm.Lock()
|
|
n := Xadd(activity, 10000)
|
|
if n != 10000 {
|
|
panic(fmt.Sprintf("wlock(%d)\n", n))
|
|
}
|
|
for i := 0; i < 100; i++ {
|
|
}
|
|
Xadd(activity, -10000)
|
|
rwm.Unlock()
|
|
}
|
|
cdone <- true
|
|
}
|
|
|
|
func HammerRWMutex(gomaxprocs, numReaders, num_iterations int) {
|
|
runtime.GOMAXPROCS(gomaxprocs)
|
|
// Number of active readers + 10000 * number of active writers.
|
|
var activity uint32
|
|
var rwm RWMutex
|
|
cdone := make(chan bool)
|
|
go writer(&rwm, num_iterations, &activity, cdone)
|
|
var i int
|
|
for i = 0; i < numReaders/2; i++ {
|
|
go reader(&rwm, num_iterations, &activity, cdone)
|
|
}
|
|
go writer(&rwm, num_iterations, &activity, cdone)
|
|
for ; i < numReaders; i++ {
|
|
go reader(&rwm, num_iterations, &activity, cdone)
|
|
}
|
|
// Wait for the 2 writers and all readers to finish.
|
|
for i := 0; i < 2+numReaders; i++ {
|
|
<-cdone
|
|
}
|
|
}
|
|
|
|
func TestRWMutex(t *testing.T) {
|
|
HammerRWMutex(1, 1, 1000)
|
|
HammerRWMutex(1, 3, 1000)
|
|
HammerRWMutex(1, 10, 1000)
|
|
HammerRWMutex(4, 1, 1000)
|
|
HammerRWMutex(4, 3, 1000)
|
|
HammerRWMutex(4, 10, 1000)
|
|
HammerRWMutex(10, 1, 1000)
|
|
HammerRWMutex(10, 3, 1000)
|
|
HammerRWMutex(10, 10, 1000)
|
|
HammerRWMutex(10, 5, 10000)
|
|
}
|