1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
|
module Concurrent
RSpec.describe CyclicBarrier do
let(:parties) { 3 }
let!(:barrier) { described_class.new(3) }
context '#initialize' do
it 'raises an exception if the initial count is less than 1' do
expect {
described_class.new(0)
}.to raise_error(ArgumentError)
end
it 'raises an exception if the initial count is not an integer' do
expect {
described_class.new('foo')
}.to raise_error(ArgumentError)
end
end
describe '#parties' do
it 'should be the value passed to the constructor' do
expect(barrier.parties).to eq 3
end
end
describe '#number_waiting' do
context 'without any waiting thread' do
it 'should be equal to zero' do
expect(barrier.number_waiting).to eq 0
end
end
context 'with waiting threads' do
it 'should be equal to the waiting threads count' do
in_thread { barrier.wait }
in_thread { barrier.wait }
repeat_until_success { expect(barrier.number_waiting).to eq 2 }
end
end
end
describe '#broken?' do
it 'should not be broken when created' do
expect(barrier.broken?).to eq false
end
it 'should not be broken when reset is called without waiting thread' do
barrier.reset
expect(barrier.broken?).to eq false
end
end
describe 'reset' do
it 'should release all waiting threads', notravis: true do
start_latch = CountDownLatch.new(1)
continue_latch = CountDownLatch.new(1)
in_thread do
start_latch.count_down
barrier.wait
continue_latch.count_down
end
start_latch.wait(1)
barrier.reset
expect(barrier).not_to be_broken
expect(barrier.number_waiting).to eq 0
end
end
describe '#wait' do
context 'without timeout' do
it 'should block the thread' do
t = in_thread { barrier.wait }
t.join(0.1)
expect(t.status).to eq 'sleep'
end
it 'should release all threads when their number matches the desired one' do
latch = CountDownLatch.new(parties)
parties.times { in_thread { barrier.wait; latch.count_down } }
expect(latch.wait(1)).to be_truthy
expect(barrier.number_waiting).to eq 0
expect(barrier).not_to be_broken
end
it 'returns true when released' do
latch = CountDownLatch.new(parties)
parties.times { in_thread { latch.count_down if barrier.wait == true } }
expect(latch.wait(1)).to be_truthy
end
it 'executes the block once' do
counter = AtomicFixnum.new
barrier = described_class.new(parties) { counter.increment }
latch = CountDownLatch.new(parties)
parties.times { in_thread { latch.count_down if barrier.wait == true } }
expect(latch.wait(1)).to be_truthy
expect(counter.value).to eq 1
end
it 'can be reused' do
first_latch = CountDownLatch.new(parties)
parties.times { in_thread { barrier.wait; first_latch.count_down } }
latch = CountDownLatch.new(parties)
parties.times { in_thread { barrier.wait; latch.count_down } }
expect(latch.wait(1)).to be_truthy
end
it 'return false if barrier has been reset', notravis: true do
latch = CountDownLatch.new(1)
t = in_thread { latch.count_down if barrier.wait == false }
t.join(0.1)
barrier.reset
expect(latch.wait(1)).to be_truthy
end
end
context 'with timeout' do
context 'timeout not expiring' do
it 'should block the thread' do
t = in_thread { barrier.wait(1) }
t.join(0.1)
expect(t.status).to eq 'sleep'
end
it 'should release all threads when their number matches the desired one' do
latch = CountDownLatch.new(parties)
parties.times { in_thread { barrier.wait(1); latch.count_down } }
expect(latch.wait(0.2)).to be_truthy
expect(barrier.number_waiting).to eq 0
end
it 'returns true when released' do
latch = CountDownLatch.new(parties)
parties.times { in_thread { latch.count_down if barrier.wait(1) == true } }
expect(latch.wait(1)).to be_truthy
end
end
context 'timeout expiring' do
it 'returns false' do
latch = CountDownLatch.new(1)
in_thread { latch.count_down if barrier.wait(0.1) == false }
expect(latch.wait(1)).to be_truthy
end
it 'breaks the barrier and release all other threads' do
latch = CountDownLatch.new(2)
in_thread { barrier.wait(0.1); latch.count_down }
in_thread { barrier.wait; latch.count_down }
expect(latch.wait(1)).to be_truthy
expect(barrier).to be_broken
end
it 'breaks the barrier and release all other threads 2' do
t1 = in_thread { barrier.wait(0.1) }
t2 = in_thread { barrier.wait(0.1) }
[t1, t2].each(&:join)
expect(barrier).to be_broken
end
it 'does not execute the block on timeout' do
counter = AtomicFixnum.new
barrier = described_class.new(parties) { counter.increment }
barrier.wait(0.1)
expect(counter.value).to eq 0
end
end
end
context '#broken barrier' do
it 'should not accept new threads' do
t = in_thread { barrier.wait(0.01) }
join_with t
expect(barrier).to be_broken
expect(barrier.wait).to be_falsey
end
it 'can be reset' do
t = in_thread { barrier.wait(0.01) }
join_with t
expect(barrier).to be_broken
barrier.reset
expect(barrier).not_to be_broken
end
end
end
context 'spurious wake ups' do
before(:each) do
def barrier.simulate_spurious_wake_up
synchronize do
ns_signal
ns_broadcast
end
end
end
it 'should resist to spurious wake ups without timeout' do
@expected = false
t = in_thread { barrier.wait; @expected = true }
t.join(0.1)
barrier.simulate_spurious_wake_up
t.join(0.1)
expect(@expected).to be_falsey
end
it 'should resist to spurious wake ups with timeout' do
@expected = false
t = in_thread { barrier.wait(0.5); @expected = true }
t.join(0.1)
barrier.simulate_spurious_wake_up
t.join(0.1)
expect(@expected).to be_falsey
end
end
end
end
|
