← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/sync/waitgroup_test.go

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-11-18 15:12:26 UTC
  • mfrom: (14.2.12 vivid-proposed)
  • Revision ID: package-import@ubuntu.com-20141118151226-zug7vn93mn3dtiz3
Tags: 2:1.3.2-1ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - Support co-installability with gccgo-go tool:
    - d/rules,golang-go.install: Rename bin/go -> bin/golang-go
    - d/golang-go.{postinst,prerm}: Install/remove /usr/bin/go using
      alternatives.
  - d/copyright: Amendments for full compiliance with copyright format.
  - d/control: Demote golang-go.tools to Suggests to support Ubuntu MIR.
  - dropped patches (now upstream):
    - d/p/issue27650045_40001_50001.diff
    - d/p/issue28050043_60001_70001.diff
    - d/p/issue54790044_100001_110001.diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/sync/waitgroup_test.go
5
5
package sync_test
6
6
 
7
7
import (
8
 
        "runtime"
9
8
        . "sync"
10
9
        "sync/atomic"
11
10
        "testing"
61
60
        t.Fatal("Should panic")
62
61
}
63
62
 
 
63
func TestWaitGroupRace(t *testing.T) {
 
64
        // Run this test for about 1ms.
 
65
        for i := 0; i < 1000; i++ {
 
66
                wg := &WaitGroup{}
 
67
                n := new(int32)
 
68
                // spawn goroutine 1
 
69
                wg.Add(1)
 
70
                go func() {
 
71
                        atomic.AddInt32(n, 1)
 
72
                        wg.Done()
 
73
                }()
 
74
                // spawn goroutine 2
 
75
                wg.Add(1)
 
76
                go func() {
 
77
                        atomic.AddInt32(n, 1)
 
78
                        wg.Done()
 
79
                }()
 
80
                // Wait for goroutine 1 and 2
 
81
                wg.Wait()
 
82
                if atomic.LoadInt32(n) != 2 {
 
83
                        t.Fatal("Spurious wakeup from Wait")
 
84
                }
 
85
        }
 
86
}
 
87
 
64
88
func BenchmarkWaitGroupUncontended(b *testing.B) {
65
89
        type PaddedWaitGroup struct {
66
90
                WaitGroup
67
91
                pad [128]uint8
68
92
        }
69
 
        const CallsPerSched = 1000
70
 
        procs := runtime.GOMAXPROCS(-1)
71
 
        N := int32(b.N / CallsPerSched)
72
 
        c := make(chan bool, procs)
73
 
        for p := 0; p < procs; p++ {
74
 
                go func() {
75
 
                        var wg PaddedWaitGroup
76
 
                        for atomic.AddInt32(&N, -1) >= 0 {
77
 
                                runtime.Gosched()
78
 
                                for g := 0; g < CallsPerSched; g++ {
79
 
                                        wg.Add(1)
80
 
                                        wg.Done()
81
 
                                        wg.Wait()
82
 
                                }
83
 
                        }
84
 
                        c <- true
85
 
                }()
86
 
        }
87
 
        for p := 0; p < procs; p++ {
88
 
                <-c
89
 
        }
 
93
        b.RunParallel(func(pb *testing.PB) {
 
94
                var wg PaddedWaitGroup
 
95
                for pb.Next() {
 
96
                        wg.Add(1)
 
97
                        wg.Done()
 
98
                        wg.Wait()
 
99
                }
 
100
        })
90
101
}
91
102
 
92
103
func benchmarkWaitGroupAddDone(b *testing.B, localWork int) {
93
 
        const CallsPerSched = 1000
94
 
        procs := runtime.GOMAXPROCS(-1)
95
 
        N := int32(b.N / CallsPerSched)
96
 
        c := make(chan bool, procs)
97
104
        var wg WaitGroup
98
 
        for p := 0; p < procs; p++ {
99
 
                go func() {
100
 
                        foo := 0
101
 
                        for atomic.AddInt32(&N, -1) >= 0 {
102
 
                                runtime.Gosched()
103
 
                                for g := 0; g < CallsPerSched; g++ {
104
 
                                        wg.Add(1)
105
 
                                        for i := 0; i < localWork; i++ {
106
 
                                                foo *= 2
107
 
                                                foo /= 2
108
 
                                        }
109
 
                                        wg.Done()
110
 
                                }
 
105
        b.RunParallel(func(pb *testing.PB) {
 
106
                foo := 0
 
107
                for pb.Next() {
 
108
                        wg.Add(1)
 
109
                        for i := 0; i < localWork; i++ {
 
110
                                foo *= 2
 
111
                                foo /= 2
111
112
                        }
112
 
                        c <- foo == 42
113
 
                }()
114
 
        }
115
 
        for p := 0; p < procs; p++ {
116
 
                <-c
117
 
        }
 
113
                        wg.Done()
 
114
                }
 
115
                _ = foo
 
116
        })
118
117
}
119
118
 
120
119
func BenchmarkWaitGroupAddDone(b *testing.B) {
126
125
}
127
126
 
128
127
func benchmarkWaitGroupWait(b *testing.B, localWork int) {
129
 
        const CallsPerSched = 1000
130
 
        procs := runtime.GOMAXPROCS(-1)
131
 
        N := int32(b.N / CallsPerSched)
132
 
        c := make(chan bool, procs)
133
128
        var wg WaitGroup
134
 
        wg.Add(procs)
135
 
        for p := 0; p < procs; p++ {
136
 
                go wg.Done()
137
 
        }
138
 
        for p := 0; p < procs; p++ {
139
 
                go func() {
140
 
                        foo := 0
141
 
                        for atomic.AddInt32(&N, -1) >= 0 {
142
 
                                runtime.Gosched()
143
 
                                for g := 0; g < CallsPerSched; g++ {
144
 
                                        wg.Wait()
145
 
                                        for i := 0; i < localWork; i++ {
146
 
                                                foo *= 2
147
 
                                                foo /= 2
148
 
                                        }
149
 
                                }
 
129
        b.RunParallel(func(pb *testing.PB) {
 
130
                foo := 0
 
131
                for pb.Next() {
 
132
                        wg.Wait()
 
133
                        for i := 0; i < localWork; i++ {
 
134
                                foo *= 2
 
135
                                foo /= 2
150
136
                        }
151
 
                        c <- foo == 42
152
 
                }()
153
 
        }
154
 
        for p := 0; p < procs; p++ {
155
 
                <-c
156
 
        }
 
137
                }
 
138
                _ = foo
 
139
        })
157
140
}
158
141
 
159
142
func BenchmarkWaitGroupWait(b *testing.B) {