URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [runtime/] [chan_test.go] - Blame information for rev 818

Go to most recent revision | Details | Compare with Previous | View Log


// 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.
 
package runtime_test
 
import (
        "runtime"
        "sync"
        "sync/atomic"
        "testing"
)
 
func TestChanSendInterface(t *testing.T) {
        type mt struct{}
        m := &mt{}
        c := make(chan interface{}, 1)
        c <- m
        select {
        case c <- m:
        default:
        }
        select {
        case c <- m:
        case c <- &mt{}:
        default:
        }
}
 
func TestPseudoRandomSend(t *testing.T) {
        n := 100
        c := make(chan int)
        l := make([]int, n)
        var m sync.Mutex
        m.Lock()
        go func() {
                for i := 0; i < n; i++ {
                        runtime.Gosched()
                        l[i] = <-c
                }
                m.Unlock()
        }()
        for i := 0; i < n; i++ {
                select {
                case c <- 0:
                case c <- 1:
                }
        }
        m.Lock() // wait
        n0 := 0
        n1 := 0
        for _, i := range l {
                n0 += (i + 1) % 2
                n1 += i
                if n0 > n/10 && n1 > n/10 {
                        return
                }
        }
        t.Errorf("Want pseudo random, got %d zeros and %d ones", n0, n1)
}
 
func TestMultiConsumer(t *testing.T) {
        const nwork = 23
        const niter = 271828
 
        pn := []int{2, 3, 7, 11, 13, 17, 19, 23, 27, 31}
 
        q := make(chan int, nwork*3)
        r := make(chan int, nwork*3)
 
        // workers
        var wg sync.WaitGroup
        for i := 0; i < nwork; i++ {
                wg.Add(1)
                go func(w int) {
                        for v := range q {
                                // mess with the fifo-ish nature of range
                                if pn[w%len(pn)] == v {
                                        runtime.Gosched()
                                }
                                r <- v
                        }
                        wg.Done()
                }(i)
        }
 
        // feeder & closer
        expect := 0
        go func() {
                for i := 0; i < niter; i++ {
                        v := pn[i%len(pn)]
                        expect += v
                        q <- v
                }
                close(q)  // no more work
                wg.Wait() // workers done
                close(r)  // ... so there can be no more results
        }()
 
        // consume & check
        n := 0
        s := 0
        for v := range r {
                n++
                s += v
        }
        if n != niter || s != expect {
                t.Errorf("Expected sum %d (got %d) from %d iter (saw %d)",
                        expect, s, niter, n)
        }
}
 
func BenchmarkSelectUncontended(b *testing.B) {
        const CallsPerSched = 1000
        procs := runtime.GOMAXPROCS(-1)
        N := int32(b.N / CallsPerSched)
        c := make(chan bool, procs)
        for p := 0; p < procs; p++ {
                go func() {
                        myc1 := make(chan int, 1)
                        myc2 := make(chan int, 1)
                        myc1 <- 0
                        for atomic.AddInt32(&N, -1) >= 0 {
                                for g := 0; g < CallsPerSched; g++ {
                                        select {
                                        case <-myc1:
                                                myc2 <- 0
                                        case <-myc2:
                                                myc1 <- 0
                                        }
                                }
                        }
                        c <- true
                }()
        }
        for p := 0; p < procs; p++ {
                <-c
        }
}
 
func BenchmarkSelectContended(b *testing.B) {
        const CallsPerSched = 1000
        procs := runtime.GOMAXPROCS(-1)
        N := int32(b.N / CallsPerSched)
        c := make(chan bool, procs)
        myc1 := make(chan int, procs)
        myc2 := make(chan int, procs)
        for p := 0; p < procs; p++ {
                myc1 <- 0
                go func() {
                        for atomic.AddInt32(&N, -1) >= 0 {
                                for g := 0; g < CallsPerSched; g++ {
                                        select {
                                        case <-myc1:
                                                myc2 <- 0
                                        case <-myc2:
                                                myc1 <- 0
                                        }
                                }
                        }
                        c <- true
                }()
        }
        for p := 0; p < procs; p++ {
                <-c
        }
}
 
func BenchmarkSelectNonblock(b *testing.B) {
        const CallsPerSched = 1000
        procs := runtime.GOMAXPROCS(-1)
        N := int32(b.N / CallsPerSched)
        c := make(chan bool, procs)
        for p := 0; p < procs; p++ {
                go func() {
                        myc1 := make(chan int)
                        myc2 := make(chan int)
                        myc3 := make(chan int, 1)
                        myc4 := make(chan int, 1)
                        for atomic.AddInt32(&N, -1) >= 0 {
                                for g := 0; g < CallsPerSched; g++ {
                                        select {
                                        case <-myc1:
                                        default:
                                        }
                                        select {
                                        case myc2 <- 0:
                                        default:
                                        }
                                        select {
                                        case <-myc3:
                                        default:
                                        }
                                        select {
                                        case myc4 <- 0:
                                        default:
                                        }
                                }
                        }
                        c <- true
                }()
        }
        for p := 0; p < procs; p++ {
                <-c
        }
}
 
func BenchmarkChanUncontended(b *testing.B) {
        const CallsPerSched = 1000
        procs := runtime.GOMAXPROCS(-1)
        N := int32(b.N / CallsPerSched)
        c := make(chan bool, procs)
        for p := 0; p < procs; p++ {
                go func() {
                        myc := make(chan int, CallsPerSched)
                        for atomic.AddInt32(&N, -1) >= 0 {
                                for g := 0; g < CallsPerSched; g++ {
                                        myc <- 0
                                }
                                for g := 0; g < CallsPerSched; g++ {
                                        <-myc
                                }
                        }
                        c <- true
                }()
        }
        for p := 0; p < procs; p++ {
                <-c
        }
}
 
func BenchmarkChanContended(b *testing.B) {
        const CallsPerSched = 1000
        procs := runtime.GOMAXPROCS(-1)
        N := int32(b.N / CallsPerSched)
        c := make(chan bool, procs)
        myc := make(chan int, procs*CallsPerSched)
        for p := 0; p < procs; p++ {
                go func() {
                        for atomic.AddInt32(&N, -1) >= 0 {
                                for g := 0; g < CallsPerSched; g++ {
                                        myc <- 0
                                }
                                for g := 0; g < CallsPerSched; g++ {
                                        <-myc
                                }
                        }
                        c <- true
                }()
        }
        for p := 0; p < procs; p++ {
                <-c
        }
}
 
func BenchmarkChanSync(b *testing.B) {
        const CallsPerSched = 1000
        procs := 2
        N := int32(b.N / CallsPerSched / procs * procs)
        c := make(chan bool, procs)
        myc := make(chan int)
        for p := 0; p < procs; p++ {
                go func() {
                        for {
                                i := atomic.AddInt32(&N, -1)
                                if i < 0 {
                                        break
                                }
                                for g := 0; g < CallsPerSched; g++ {
                                        if i%2 == 0 {
                                                <-myc
                                                myc <- 0
                                        } else {
                                                myc <- 0
                                                <-myc
                                        }
                                }
                        }
                        c <- true
                }()
        }
        for p := 0; p < procs; p++ {
                <-c
        }
}
 
func benchmarkChanProdCons(b *testing.B, chanSize, localWork int) {
        const CallsPerSched = 1000
        procs := runtime.GOMAXPROCS(-1)
        N := int32(b.N / CallsPerSched)
        c := make(chan bool, 2*procs)
        myc := make(chan int, chanSize)
        for p := 0; p < procs; p++ {
                go func() {
                        foo := 0
                        for atomic.AddInt32(&N, -1) >= 0 {
                                for g := 0; g < CallsPerSched; g++ {
                                        for i := 0; i < localWork; i++ {
                                                foo *= 2
                                                foo /= 2
                                        }
                                        myc <- 1
                                }
                        }
                        myc <- 0
                        c <- foo == 42
                }()
                go func() {
                        foo := 0
                        for {
                                v := <-myc
                                if v == 0 {
                                        break
                                }
                                for i := 0; i < localWork; i++ {
                                        foo *= 2
                                        foo /= 2
                                }
                        }
                        c <- foo == 42
                }()
        }
        for p := 0; p < procs; p++ {
                <-c
                <-c
        }
}
 
func BenchmarkChanProdCons0(b *testing.B) {
        benchmarkChanProdCons(b, 0, 0)
}
 
func BenchmarkChanProdCons10(b *testing.B) {
        benchmarkChanProdCons(b, 10, 0)
}
 
func BenchmarkChanProdCons100(b *testing.B) {
        benchmarkChanProdCons(b, 100, 0)
}
 
func BenchmarkChanProdConsWork0(b *testing.B) {
        benchmarkChanProdCons(b, 0, 100)
}
 
func BenchmarkChanProdConsWork10(b *testing.B) {
        benchmarkChanProdCons(b, 10, 100)
}
 
func BenchmarkChanProdConsWork100(b *testing.B) {
        benchmarkChanProdCons(b, 100, 100)
}
 
func BenchmarkChanCreation(b *testing.B) {
        const CallsPerSched = 1000
        procs := runtime.GOMAXPROCS(-1)
        N := int32(b.N / CallsPerSched)
        c := make(chan bool, procs)
        for p := 0; p < procs; p++ {
                go func() {
                        for atomic.AddInt32(&N, -1) >= 0 {
                                for g := 0; g < CallsPerSched; g++ {
                                        myc := make(chan int, 1)
                                        myc <- 0
                                        <-myc
                                }
                        }
                        c <- true
                }()
        }
        for p := 0; p < procs; p++ {
                <-c
        }
}
 
func BenchmarkChanSem(b *testing.B) {
        type Empty struct{}
        c := make(chan Empty, 1)
        for i := 0; i < b.N; i++ {
                c <- Empty{}
                <-c
        }
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [runtime/] [chan_test.go] - Blame information for rev 818

Line No.	Rev	Author	Line
1	747	jeremybenn	`// 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			`package runtime_test`
6
7			`import (`
8			`"runtime"`
9			`"sync"`
10			`"sync/atomic"`
11			`"testing"`
12			`)`
13
14			`func TestChanSendInterface(t *testing.T) {`
15			`type mt struct{}`
16			`m := &mt{}`
17			`c := make(chan interface{}, 1)`
18			`c <- m`
19			`select {`
20			`case c <- m:`
21			`default:`
22			`}`
23			`select {`
24			`case c <- m:`
25			`case c <- &mt{}:`
26			`default:`
27			`}`
28			`}`
29
30			`func TestPseudoRandomSend(t *testing.T) {`
31			`n := 100`
32			`c := make(chan int)`
33			`l := make([]int, n)`
34			`var m sync.Mutex`
35			`m.Lock()`
36			`go func() {`
37			`for i := 0; i < n; i++ {`
38			`runtime.Gosched()`
39			`l[i] = <-c`
40			`}`
41			`m.Unlock()`
42			`}()`
43			`for i := 0; i < n; i++ {`
44			`select {`
45			`case c <- 0:`
46			`case c <- 1:`
47			`}`
48			`}`
49			`m.Lock() // wait`
50			`n0 := 0`
51			`n1 := 0`
52			`for _, i := range l {`
53			`n0 += (i + 1) % 2`
54			`n1 += i`
55			`if n0 > n/10 && n1 > n/10 {`
56			`return`
57			`}`
58			`}`
59			`t.Errorf("Want pseudo random, got %d zeros and %d ones", n0, n1)`
60			`}`
61
62			`func TestMultiConsumer(t *testing.T) {`
63			`const nwork = 23`
64			`const niter = 271828`
65
66			`pn := []int{2, 3, 7, 11, 13, 17, 19, 23, 27, 31}`
67
68			`q := make(chan int, nwork*3)`
69			`r := make(chan int, nwork*3)`
70
71			`// workers`
72			`var wg sync.WaitGroup`
73			`for i := 0; i < nwork; i++ {`
74			`wg.Add(1)`
75			`go func(w int) {`
76			`for v := range q {`
77			`// mess with the fifo-ish nature of range`
78			`if pn[w%len(pn)] == v {`
79			`runtime.Gosched()`
80			`}`
81			`r <- v`
82			`}`
83			`wg.Done()`
84			`}(i)`
85			`}`
86
87			`// feeder & closer`
88			`expect := 0`
89			`go func() {`
90			`for i := 0; i < niter; i++ {`
91			`v := pn[i%len(pn)]`
92			`expect += v`
93			`q <- v`
94			`}`
95			`close(q) // no more work`
96			`wg.Wait() // workers done`
97			`close(r) // ... so there can be no more results`
98			`}()`
99
100			`// consume & check`
101			`n := 0`
102			`s := 0`
103			`for v := range r {`
104			`n++`
105			`s += v`
106			`}`
107			`if n != niter \|\| s != expect {`
108			`t.Errorf("Expected sum %d (got %d) from %d iter (saw %d)",`
109			`expect, s, niter, n)`
110			`}`
111			`}`
112
113			`func BenchmarkSelectUncontended(b *testing.B) {`
114			`const CallsPerSched = 1000`
115			`procs := runtime.GOMAXPROCS(-1)`
116			`N := int32(b.N / CallsPerSched)`
117			`c := make(chan bool, procs)`
118			`for p := 0; p < procs; p++ {`
119			`go func() {`
120			`myc1 := make(chan int, 1)`
121			`myc2 := make(chan int, 1)`
122			`myc1 <- 0`
123			`for atomic.AddInt32(&N, -1) >= 0 {`
124			`for g := 0; g < CallsPerSched; g++ {`
125			`select {`
126			`case <-myc1:`
127			`myc2 <- 0`
128			`case <-myc2:`
129			`myc1 <- 0`
130			`}`
131			`}`
132			`}`
133			`c <- true`
134			`}()`
135			`}`
136			`for p := 0; p < procs; p++ {`
137			`<-c`
138			`}`
139			`}`
140
141			`func BenchmarkSelectContended(b *testing.B) {`
142			`const CallsPerSched = 1000`
143			`procs := runtime.GOMAXPROCS(-1)`
144			`N := int32(b.N / CallsPerSched)`
145			`c := make(chan bool, procs)`
146			`myc1 := make(chan int, procs)`
147			`myc2 := make(chan int, procs)`
148			`for p := 0; p < procs; p++ {`
149			`myc1 <- 0`
150			`go func() {`
151			`for atomic.AddInt32(&N, -1) >= 0 {`
152			`for g := 0; g < CallsPerSched; g++ {`
153			`select {`
154			`case <-myc1:`
155			`myc2 <- 0`
156			`case <-myc2:`
157			`myc1 <- 0`
158			`}`
159			`}`
160			`}`
161			`c <- true`
162			`}()`
163			`}`
164			`for p := 0; p < procs; p++ {`
165			`<-c`
166			`}`
167			`}`
168
169			`func BenchmarkSelectNonblock(b *testing.B) {`
170			`const CallsPerSched = 1000`
171			`procs := runtime.GOMAXPROCS(-1)`
172			`N := int32(b.N / CallsPerSched)`
173			`c := make(chan bool, procs)`
174			`for p := 0; p < procs; p++ {`
175			`go func() {`
176			`myc1 := make(chan int)`
177			`myc2 := make(chan int)`
178			`myc3 := make(chan int, 1)`
179			`myc4 := make(chan int, 1)`
180			`for atomic.AddInt32(&N, -1) >= 0 {`
181			`for g := 0; g < CallsPerSched; g++ {`
182			`select {`
183			`case <-myc1:`
184			`default:`
185			`}`
186			`select {`
187			`case myc2 <- 0:`
188			`default:`
189			`}`
190			`select {`
191			`case <-myc3:`
192			`default:`
193			`}`
194			`select {`
195			`case myc4 <- 0:`
196			`default:`
197			`}`
198			`}`
199			`}`
200			`c <- true`
201			`}()`
202			`}`
203			`for p := 0; p < procs; p++ {`
204			`<-c`
205			`}`
206			`}`
207
208			`func BenchmarkChanUncontended(b *testing.B) {`
209			`const CallsPerSched = 1000`
210			`procs := runtime.GOMAXPROCS(-1)`
211			`N := int32(b.N / CallsPerSched)`
212			`c := make(chan bool, procs)`
213			`for p := 0; p < procs; p++ {`
214			`go func() {`
215			`myc := make(chan int, CallsPerSched)`
216			`for atomic.AddInt32(&N, -1) >= 0 {`
217			`for g := 0; g < CallsPerSched; g++ {`
218			`myc <- 0`
219			`}`
220			`for g := 0; g < CallsPerSched; g++ {`
221			`<-myc`
222			`}`
223			`}`
224			`c <- true`
225			`}()`
226			`}`
227			`for p := 0; p < procs; p++ {`
228			`<-c`
229			`}`
230			`}`
231
232			`func BenchmarkChanContended(b *testing.B) {`
233			`const CallsPerSched = 1000`
234			`procs := runtime.GOMAXPROCS(-1)`
235			`N := int32(b.N / CallsPerSched)`
236			`c := make(chan bool, procs)`
237			`myc := make(chan int, procs*CallsPerSched)`
238			`for p := 0; p < procs; p++ {`
239			`go func() {`
240			`for atomic.AddInt32(&N, -1) >= 0 {`
241			`for g := 0; g < CallsPerSched; g++ {`
242			`myc <- 0`
243			`}`
244			`for g := 0; g < CallsPerSched; g++ {`
245			`<-myc`
246			`}`
247			`}`
248			`c <- true`
249			`}()`
250			`}`
251			`for p := 0; p < procs; p++ {`
252			`<-c`
253			`}`
254			`}`
255
256			`func BenchmarkChanSync(b *testing.B) {`
257			`const CallsPerSched = 1000`
258			`procs := 2`
259			`N := int32(b.N / CallsPerSched / procs * procs)`
260			`c := make(chan bool, procs)`
261			`myc := make(chan int)`
262			`for p := 0; p < procs; p++ {`
263			`go func() {`
264			`for {`
265			`i := atomic.AddInt32(&N, -1)`
266			`if i < 0 {`
267			`break`
268			`}`
269			`for g := 0; g < CallsPerSched; g++ {`
270			`if i%2 == 0 {`
271			`<-myc`
272			`myc <- 0`
273			`} else {`
274			`myc <- 0`
275			`<-myc`
276			`}`
277			`}`
278			`}`
279			`c <- true`
280			`}()`
281			`}`
282			`for p := 0; p < procs; p++ {`
283			`<-c`
284			`}`
285			`}`
286
287			`func benchmarkChanProdCons(b *testing.B, chanSize, localWork int) {`
288			`const CallsPerSched = 1000`
289			`procs := runtime.GOMAXPROCS(-1)`
290			`N := int32(b.N / CallsPerSched)`
291			`c := make(chan bool, 2*procs)`
292			`myc := make(chan int, chanSize)`
293			`for p := 0; p < procs; p++ {`
294			`go func() {`
295			`foo := 0`
296			`for atomic.AddInt32(&N, -1) >= 0 {`
297			`for g := 0; g < CallsPerSched; g++ {`
298			`for i := 0; i < localWork; i++ {`
299			`foo *= 2`
300			`foo /= 2`
301			`}`
302			`myc <- 1`
303			`}`
304			`}`
305			`myc <- 0`
306			`c <- foo == 42`
307			`}()`
308			`go func() {`
309			`foo := 0`
310			`for {`
311			`v := <-myc`
312			`if v == 0 {`
313			`break`
314			`}`
315			`for i := 0; i < localWork; i++ {`
316			`foo *= 2`
317			`foo /= 2`
318			`}`
319			`}`
320			`c <- foo == 42`
321			`}()`
322			`}`
323			`for p := 0; p < procs; p++ {`
324			`<-c`
325			`<-c`
326			`}`
327			`}`
328
329			`func BenchmarkChanProdCons0(b *testing.B) {`
330			`benchmarkChanProdCons(b, 0, 0)`
331			`}`
332
333			`func BenchmarkChanProdCons10(b *testing.B) {`
334			`benchmarkChanProdCons(b, 10, 0)`
335			`}`
336
337			`func BenchmarkChanProdCons100(b *testing.B) {`
338			`benchmarkChanProdCons(b, 100, 0)`
339			`}`
340
341			`func BenchmarkChanProdConsWork0(b *testing.B) {`
342			`benchmarkChanProdCons(b, 0, 100)`
343			`}`
344
345			`func BenchmarkChanProdConsWork10(b *testing.B) {`
346			`benchmarkChanProdCons(b, 10, 100)`
347			`}`
348
349			`func BenchmarkChanProdConsWork100(b *testing.B) {`
350			`benchmarkChanProdCons(b, 100, 100)`
351			`}`
352
353			`func BenchmarkChanCreation(b *testing.B) {`
354			`const CallsPerSched = 1000`
355			`procs := runtime.GOMAXPROCS(-1)`
356			`N := int32(b.N / CallsPerSched)`
357			`c := make(chan bool, procs)`
358			`for p := 0; p < procs; p++ {`
359			`go func() {`
360			`for atomic.AddInt32(&N, -1) >= 0 {`
361			`for g := 0; g < CallsPerSched; g++ {`
362			`myc := make(chan int, 1)`
363			`myc <- 0`
364			`<-myc`
365			`}`
366			`}`
367			`c <- true`
368			`}()`
369			`}`
370			`for p := 0; p < procs; p++ {`
371			`<-c`
372			`}`
373			`}`
374
375			`func BenchmarkChanSem(b *testing.B) {`
376			`type Empty struct{}`
377			`c := make(chan Empty, 1)`
378			`for i := 0; i < b.N; i++ {`
379			`c <- Empty{}`
380			`<-c`
381			`}`
382			`}`