source: tests/unified_locking/locks.cfa @ 6825167

pthread-emulationqualifiedEnum
Last change on this file since 6825167 was ec57856, checked in by caparsons <caparson@…>, 5 months ago

added fast lock tests

  • Property mode set to 100644
File size: 6.2 KB
Line 
1#include <stdio.h>
2#include "locks.hfa"
3#include <stdlib.hfa>
4#include <thread.hfa>
5
6const unsigned int num_times = 50000;
7
8multiple_acquisition_lock m;
9condition_variable( multiple_acquisition_lock ) c_m;
10
11single_acquisition_lock s;
12condition_variable( single_acquisition_lock ) c_s;
13
14owner_lock o;
15condition_variable( owner_lock ) c_o;
16
17linear_backoff_then_block_lock l;
18condition_variable( linear_backoff_then_block_lock ) c_l;
19
20fast_block_lock f;
21fast_cond_var( fast_block_lock ) f_c_f;
22
23thread T_C_M_WS1 {};
24
25void main( T_C_M_WS1 & this ) {
26        for (unsigned int i = 0; i < num_times; i++) {
27                lock(m);
28                if(empty(c_m) && i != num_times - 1) {
29                        wait(c_m,m);
30                }else{
31                        notify_one(c_m);
32                }
33                unlock(m);
34        }
35}
36
37thread T_C_M_WB1 {};
38
39void main( T_C_M_WB1 & this ) {
40        for (unsigned int i = 0; i < num_times; i++) {
41                lock(m);
42                if(counter(c_m) == 3 || i == num_times - 1) {
43                        notify_all(c_m);
44                }else{
45                        wait(c_m,m);
46                }
47                unlock(m);
48        }
49}
50
51thread T_C_S_WS1 {};
52
53void main( T_C_S_WS1 & this ) {
54        for (unsigned int i = 0; i < num_times; i++) {
55                lock(s);
56                if(empty(c_s) && i != num_times - 1) {
57                        wait(c_s,s);
58                }else{
59                        notify_one(c_s);
60                }
61                unlock(s);
62        }
63}
64
65thread T_C_S_WB1 {};
66
67void main( T_C_S_WB1 & this ) {
68        for (unsigned int i = 0; i < num_times; i++) {
69                lock(s);
70                if(counter(c_s) == 3 || i == num_times - 1) {
71                        notify_all(c_s);
72                }else{
73                        wait(c_s,s);
74                }
75                unlock(s);
76        }
77}
78
79thread T_C_L_WS1 {};
80
81void main( T_C_L_WS1 & this ) {
82        for (unsigned int i = 0; i < num_times; i++) {
83                lock(l);
84                if(empty(c_l) && i != num_times - 1) {
85                        wait(c_l,l);
86                }else{
87                        notify_one(c_l);
88                }
89                unlock(l);
90        }
91}
92
93thread T_C_L_WB1 {};
94
95void main( T_C_L_WB1 & this ) {
96        for (unsigned int i = 0; i < num_times; i++) {
97                lock(l);
98                if(counter(c_l) == 3 || i == num_times - 1) {
99                        notify_all(c_l);
100                }else{
101                        wait(c_l,l);
102                }
103                unlock(l);
104        }
105}
106
107thread T_F_C_F_WS1 {};
108
109void main( T_F_C_F_WS1 & this ) {
110        for (unsigned int i = 0; i < num_times; i++) {
111                lock(f);
112                if(empty(f_c_f) && i != num_times - 1) {
113                        wait(f_c_f,f);
114                }else{
115                        notify_one(f_c_f);
116                        unlock(f);
117                }
118        }
119}
120
121thread T_C_O_WS1 {};
122
123void main( T_C_O_WS1 & this ) {
124        for (unsigned int i = 0; i < num_times; i++) {
125                lock(o);
126                if(empty(c_o) && i != num_times - 1) {
127                        wait(c_o,o);
128                }else{
129                        notify_one(c_o);
130                }
131                unlock(o);
132        }
133}
134
135thread T_C_O_WB1 {};
136
137void main( T_C_O_WB1 & this ) {
138        for (unsigned int i = 0; i < num_times; i++) {
139                lock(o);
140                if(counter(c_o) == 3 || i == num_times - 1) {
141                        notify_all(c_o);
142                }else{
143                        wait(c_o,o);
144                }
145                unlock(o);
146        }
147}
148
149thread T_C_M_WS2 {};
150
151void main( T_C_M_WS2 & this ) {
152        for (unsigned int i = 0; i < num_times; i++) {
153                lock(m);
154                lock(m);
155                lock(m);
156                if(empty(c_m) && i != num_times - 1) {
157                        wait(c_m,m);
158                }else{
159                        notify_one(c_m);
160                }
161                unlock(m);
162                unlock(m);
163                unlock(m);
164        }
165}
166
167thread T_C_O_WS2 {};
168
169void main( T_C_O_WS2 & this ) {
170        for (unsigned int i = 0; i < num_times; i++) {
171                lock(o);
172                lock(o);
173                lock(o);
174                if(empty(c_o) && i != num_times - 1) {
175                        wait(c_o,o);
176                }else{
177                        notify_one(c_o);
178                }
179                unlock(o);
180                unlock(o);
181                unlock(o);
182        }
183}
184
185thread T_C_NLW {};
186
187void main( T_C_NLW & this ) {
188        for (unsigned int i = 0; i < num_times; i++) {
189                wait(c_o);
190        }
191}
192
193thread T_C_NLS {};
194
195void main( T_C_NLS & this ) {
196        for (unsigned int i = 0; i < num_times; i++) {
197                while (empty(c_o)) { }
198                notify_one(c_o);
199        }
200}
201
202thread T_C_S_WNF {};
203
204void main( T_C_S_WNF & this ) {
205        for (unsigned int i = 0; i < num_times; i++) {
206                lock(s);
207                if(empty(c_s) && i != num_times - 1) {
208                        wait(c_s, s, 10);
209                }else{
210                        if(!empty(c_s)) assert(front(c_s) == 10);
211                        notify_one(c_s);
212                }
213                unlock(s);
214        }
215}
216
217bool done = false;
218
219thread T_C_NLWD {};
220
221void main( T_C_NLWD & this ) {
222        done = false;
223        for (unsigned int i = 0; i < num_times/5; i++) {
224                if (i % 1000 == 0) printf("Iteration: %d\n", i);
225                wait(c_s, 1`ns);
226        }
227        done = true;
228}
229
230thread T_C_WDS {};
231
232void main( T_C_WDS & this ) {
233        for (unsigned int i = 0; i < num_times; i++) {
234                while (empty(c_s) && !done) { }
235                notify_one(c_s);
236                sleep(1`ns);
237                if(done) break;
238        }
239}
240
241thread T_C_LWD {};
242
243void main( T_C_LWD & this ) {
244        done = false;
245        for (unsigned int i = 0; i < num_times/5; i++) {
246                if (i % 1000 == 0) printf("Iteration: %d\n", i);
247                lock(s);
248                wait(c_s, s, 1`ns);
249                unlock(s);
250        }
251        done = true;
252}
253
254thread T_C_LWDS {};
255
256void main( T_C_LWDS & this ) {
257        for (unsigned int i = 0; i < num_times; i++) {
258                while (empty(c_s) && !done) { }
259                lock(s);
260                notify_one(c_s);
261                unlock(s);
262                sleep(1`ns);
263                if(done) break;
264        }
265}
266
267int main() {
268        processor p[2];
269        printf("Start Test 1: multi acquisition lock and condition variable single wait/notify\n");
270        {
271                T_C_M_WS1 t1[2];
272        }
273        printf("Done Test 1\n");
274
275        printf("Start Test 2: multi acquisition lock and condition variable 3 wait/notify all\n");
276        {
277                T_C_M_WB1 t1[4];
278        }
279        printf("Done Test 2\n");
280
281        printf("Start Test 3: single acquisition lock and condition variable single wait/notify\n");
282        {
283                T_C_S_WS1 t1[2];
284        }
285        printf("Done Test 3\n");
286
287        printf("Start Test 4: single acquisition lock and condition variable 3 wait/notify all\n");
288        {
289                T_C_S_WB1 t1[4];
290        }
291        printf("Done Test 4\n");
292
293        printf("Start Test 5: owner lock and condition variable single wait/notify\n");
294        {
295                T_C_O_WS1 t1[2];
296        }
297        printf("Done Test 5\n");
298
299        printf("Start Test 6: owner lock and condition variable 3 wait/notify all\n");
300        {
301                T_C_O_WB1 t1[4];
302        }
303        printf("Done Test 6\n");
304
305        printf("Start Test 7: linear backoff lock and condition variable single wait/notify\n");
306        {
307                T_C_L_WS1 t1[2];
308        }
309        printf("Done Test 7\n");
310
311        printf("Start Test 8: linear backoff lock and condition variable 3 wait/notify all\n");
312        {
313                T_C_L_WB1 t1[4];
314        }
315        printf("Done Test 8\n");
316
317        printf("Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify\n");
318        {
319                T_C_M_WS2 t1[2];
320        }
321        printf("Done Test 9\n");
322
323        printf("Start Test 10: owner lock and condition variable multiple acquire and wait/notify\n");
324        {
325                T_C_O_WS2 t1[2];
326        }
327        printf("Done Test 10\n");
328
329        printf("Start Test 11: no lock condition variable wait/notify\n");
330        {
331                T_C_NLW t1;
332                T_C_NLS t2;
333        }
334        printf("Done Test 11\n");
335
336        printf("Start Test 12: locked condition variable wait/notify with front()\n");
337        {
338                T_C_S_WNF t1[2];
339        }
340        printf("Done Test 12\n");
341
342        printf("Start Test 13: fast block lock and fast cond var single wait/notify\n");
343        {
344                T_F_C_F_WS1 t1[2];
345        }
346        printf("Done Test 13\n");
347       
348}
Note: See TracBrowser for help on using the repository browser.