1 /*
2 * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved.
3 *
4 * This file is covered by the GNU general public license, version 2.
5 * see COPYING for details.
6 */
7
8 /* Some basic sanity tests. These do not test the barrier semantics. */
9
10 #undef TA_assert
11 #define TA_assert(e) \
12 if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: )\n", \
13 __FILE__, __LINE__), exit(1); }
14
15 #undef MISSING
16 #define MISSING(name) \
17 printf("Missing: %s\n", #name "")
18
test_atomic(void)19 void test_atomic(void)
20 {
21 AO_t x;
22 unsigned char b;
23 unsigned short s;
24 unsigned int zz;
25 # if defined(AO_HAVE_test_and_set)
26 AO_TS_t z = AO_TS_INITIALIZER;
27 # endif
28 # if defined(AO_HAVE_double_compare_and_swap) \
29 || defined(AO_HAVE_double_load) \
30 || defined(AO_HAVE_double_store)
31 AO_double_t old_w;
32 AO_double_t new_w;
33 # endif
34 # if defined(AO_HAVE_compare_and_swap_double) \
35 || defined(AO_HAVE_compare_double_and_swap_double) \
36 || defined(AO_HAVE_double_compare_and_swap)
37 AO_double_t w;
38 w.AO_val1 = 0;
39 w.AO_val2 = 0;
40 # endif
41
42 # if defined(AO_HAVE_nop)
43 AO_nop();
44 # elif !defined(AO_HAVE_nop) || !defined(AO_HAVE_nop_full) \
45 || !defined(AO_HAVE_nop_read) || !defined(AO_HAVE_nop_write)
46 MISSING(AO_nop);
47 # endif
48 # if defined(AO_HAVE_store)
49 AO_store(&x, 13);
50 TA_assert (x == 13);
51 # else
52 # if !defined(AO_HAVE_store) || !defined(AO_HAVE_store_full) \
53 || !defined(AO_HAVE_store_release) \
54 || !defined(AO_HAVE_store_release_write) \
55 || !defined(AO_HAVE_store_write)
56 MISSING(AO_store);
57 # endif
58 x = 13;
59 # endif
60 # if defined(AO_HAVE_load)
61 TA_assert(AO_load(&x) == 13);
62 # elif !defined(AO_HAVE_load) || !defined(AO_HAVE_load_acquire) \
63 || !defined(AO_HAVE_load_acquire_read) \
64 || !defined(AO_HAVE_load_dd_acquire_read) \
65 || !defined(AO_HAVE_load_full) || !defined(AO_HAVE_load_read)
66 MISSING(AO_load);
67 # endif
68 # if defined(AO_HAVE_test_and_set)
69 assert(AO_test_and_set(&z) == AO_TS_CLEAR);
70 assert(AO_test_and_set(&z) == AO_TS_SET);
71 assert(AO_test_and_set(&z) == AO_TS_SET);
72 AO_CLEAR(&z);
73 # else
74 MISSING(AO_test_and_set);
75 # endif
76 # if defined(AO_HAVE_fetch_and_add)
77 TA_assert(AO_fetch_and_add(&x, 42) == 13);
78 TA_assert(AO_fetch_and_add(&x, (AO_t)(-42)) == 55);
79 # else
80 MISSING(AO_fetch_and_add);
81 # endif
82 # if defined(AO_HAVE_fetch_and_add1)
83 TA_assert(AO_fetch_and_add1(&x) == 13);
84 # else
85 MISSING(AO_fetch_and_add1);
86 ++x;
87 # endif
88 # if defined(AO_HAVE_fetch_and_sub1)
89 TA_assert(AO_fetch_and_sub1(&x) == 14);
90 # else
91 MISSING(AO_fetch_and_sub1);
92 --x;
93 # endif
94 # if defined(AO_HAVE_short_store)
95 AO_short_store(&s, 13);
96 # else
97 # if !defined(AO_HAVE_short_store) || !defined(AO_HAVE_short_store_full) \
98 || !defined(AO_HAVE_short_store_release) \
99 || !defined(AO_HAVE_short_store_release_write) \
100 || !defined(AO_HAVE_short_store_write)
101 MISSING(AO_short_store);
102 # endif
103 s = 13;
104 # endif
105 # if defined(AO_HAVE_short_load)
106 TA_assert(AO_short_load(&s) == 13);
107 # elif !defined(AO_HAVE_short_load) || !defined(AO_HAVE_short_load_acquire) \
108 || !defined(AO_HAVE_short_load_acquire_read) \
109 || !defined(AO_HAVE_short_load_dd_acquire_read) \
110 || !defined(AO_HAVE_short_load_full) \
111 || !defined(AO_HAVE_short_load_read)
112 MISSING(AO_short_load);
113 # endif
114 # if defined(AO_HAVE_short_fetch_and_add)
115 TA_assert(AO_short_fetch_and_add(&s, 42) == 13);
116 TA_assert(AO_short_fetch_and_add(&s, (unsigned short)-42) == 55);
117 # else
118 MISSING(AO_short_fetch_and_add);
119 # endif
120 # if defined(AO_HAVE_short_fetch_and_add1)
121 TA_assert(AO_short_fetch_and_add1(&s) == 13);
122 # else
123 MISSING(AO_short_fetch_and_add1);
124 ++s;
125 # endif
126 # if defined(AO_HAVE_short_fetch_and_sub1)
127 TA_assert(AO_short_fetch_and_sub1(&s) == 14);
128 # else
129 MISSING(AO_short_fetch_and_sub1);
130 --s;
131 # endif
132 # if defined(AO_HAVE_char_store)
133 AO_char_store(&b, 13);
134 # else
135 # if !defined(AO_HAVE_char_store) || !defined(AO_HAVE_char_store_full) \
136 || !defined(AO_HAVE_char_store_release) \
137 || !defined(AO_HAVE_char_store_release_write) \
138 || !defined(AO_HAVE_char_store_write)
139 MISSING(AO_char_store);
140 # endif
141 b = 13;
142 # endif
143 # if defined(AO_HAVE_char_load)
144 TA_assert(AO_char_load(&b) == 13);
145 # elif !defined(AO_HAVE_char_load) || !defined(AO_HAVE_char_load_acquire) \
146 || !defined(AO_HAVE_char_load_acquire_read) \
147 || !defined(AO_HAVE_char_load_dd_acquire_read) \
148 || !defined(AO_HAVE_char_load_full) || !defined(AO_HAVE_char_load_read)
149 MISSING(AO_char_load);
150 # endif
151 # if defined(AO_HAVE_char_fetch_and_add)
152 TA_assert(AO_char_fetch_and_add(&b, 42) == 13);
153 TA_assert(AO_char_fetch_and_add(&b, (unsigned char)-42) == 55);
154 # else
155 MISSING(AO_char_fetch_and_add);
156 # endif
157 # if defined(AO_HAVE_char_fetch_and_add1)
158 TA_assert(AO_char_fetch_and_add1(&b) == 13);
159 # else
160 MISSING(AO_char_fetch_and_add1);
161 ++b;
162 # endif
163 # if defined(AO_HAVE_char_fetch_and_sub1)
164 TA_assert(AO_char_fetch_and_sub1(&b) == 14);
165 # else
166 MISSING(AO_char_fetch_and_sub1);
167 --b;
168 # endif
169 # if defined(AO_HAVE_int_store)
170 AO_int_store(&zz, 13);
171 # else
172 # if !defined(AO_HAVE_int_store) || !defined(AO_HAVE_int_store_full) \
173 || !defined(AO_HAVE_int_store_release) \
174 || !defined(AO_HAVE_int_store_release_write) \
175 || !defined(AO_HAVE_int_store_write)
176 MISSING(AO_int_store);
177 # endif
178 zz = 13;
179 # endif
180 # if defined(AO_HAVE_int_load)
181 TA_assert(AO_int_load(&zz) == 13);
182 # elif !defined(AO_HAVE_int_load) || !defined(AO_HAVE_int_load_acquire) \
183 || !defined(AO_HAVE_int_load_acquire_read) \
184 || !defined(AO_HAVE_int_load_dd_acquire_read) \
185 || !defined(AO_HAVE_int_load_full) || !defined(AO_HAVE_int_load_read)
186 MISSING(AO_int_load);
187 # endif
188 # if defined(AO_HAVE_int_fetch_and_add)
189 TA_assert(AO_int_fetch_and_add(&zz, 42) == 13);
190 TA_assert(AO_int_fetch_and_add(&zz, (unsigned int)-42) == 55);
191 # else
192 MISSING(AO_int_fetch_and_add);
193 # endif
194 # if defined(AO_HAVE_int_fetch_and_add1)
195 TA_assert(AO_int_fetch_and_add1(&zz) == 13);
196 # else
197 MISSING(AO_int_fetch_and_add1);
198 ++zz;
199 # endif
200 # if defined(AO_HAVE_int_fetch_and_sub1)
201 TA_assert(AO_int_fetch_and_sub1(&zz) == 14);
202 # else
203 MISSING(AO_int_fetch_and_sub1);
204 --zz;
205 # endif
206 # if defined(AO_HAVE_compare_and_swap)
207 TA_assert(!AO_compare_and_swap(&x, 14, 42));
208 TA_assert(x == 13);
209 TA_assert(AO_compare_and_swap(&x, 13, 42));
210 TA_assert(x == 42);
211 # else
212 MISSING(AO_compare_and_swap);
213 if (x == 13) x = 42;
214 # endif
215 # if defined(AO_HAVE_or)
216 AO_or(&x, 66);
217 TA_assert(x == 106);
218 # else
219 MISSING(AO_or);
220 x |= 66;
221 # endif
222 # if defined(AO_HAVE_xor)
223 AO_xor(&x, 181);
224 TA_assert(x == 223);
225 # else
226 MISSING(AO_xor);
227 x ^= 181;
228 # endif
229 # if defined(AO_HAVE_and)
230 AO_and(&x, 57);
231 TA_assert(x == 25);
232 # else
233 MISSING(AO_and);
234 x &= 57;
235 # endif
236 # if defined(AO_HAVE_fetch_compare_and_swap)
237 TA_assert(AO_fetch_compare_and_swap(&x, 14, 117) == 25);
238 TA_assert(x == 25);
239 TA_assert(AO_fetch_compare_and_swap(&x, 25, 117) == 25);
240 TA_assert(x == 117);
241 # else
242 MISSING(AO_fetch_compare_and_swap);
243 if (x == 25) x = 117;
244 # endif
245 # if defined(AO_HAVE_double_load)
246 old_w.AO_val1 = 3316;
247 old_w.AO_val2 = 2921;
248 new_w = AO_double_load(&old_w);
249 TA_assert(new_w.AO_val1 == 3316 && new_w.AO_val2 == 2921);
250 # elif !defined(AO_HAVE_double_load) \
251 || !defined(AO_HAVE_double_load_acquire) \
252 || !defined(AO_HAVE_double_load_acquire_read) \
253 || !defined(AO_HAVE_double_load_dd_acquire_read) \
254 || !defined(AO_HAVE_double_load_full) \
255 || !defined(AO_HAVE_double_load_read)
256 MISSING(AO_double_load);
257 # endif
258 # if defined(AO_HAVE_double_store)
259 new_w.AO_val1 = 1375;
260 new_w.AO_val2 = 8243;
261 AO_double_store(&old_w, new_w);
262 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
263 AO_double_store(&old_w, new_w);
264 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
265 new_w.AO_val1 ^= old_w.AO_val1;
266 new_w.AO_val2 ^= old_w.AO_val2;
267 AO_double_store(&old_w, new_w);
268 TA_assert(old_w.AO_val1 == 0 && old_w.AO_val2 == 0);
269 # elif !defined(AO_HAVE_double_store) \
270 || !defined(AO_HAVE_double_store_full) \
271 || !defined(AO_HAVE_double_store_release) \
272 || !defined(AO_HAVE_double_store_release_write) \
273 || !defined(AO_HAVE_double_store_write)
274 MISSING(AO_double_store);
275 # endif
276 # if defined(AO_HAVE_compare_double_and_swap_double)
277 TA_assert(!AO_compare_double_and_swap_double(&w, 17, 42, 12, 13));
278 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
279 TA_assert(AO_compare_double_and_swap_double(&w, 0, 0, 12, 13));
280 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
281 TA_assert(!AO_compare_double_and_swap_double(&w, 12, 14, 64, 33));
282 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
283 TA_assert(!AO_compare_double_and_swap_double(&w, 11, 13, 85, 82));
284 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
285 TA_assert(!AO_compare_double_and_swap_double(&w, 13, 12, 17, 42));
286 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
287 TA_assert(AO_compare_double_and_swap_double(&w, 12, 13, 17, 42));
288 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
289 TA_assert(AO_compare_double_and_swap_double(&w, 17, 42, 0, 0));
290 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
291 # else
292 MISSING(AO_compare_double_and_swap_double);
293 # endif
294 # if defined(AO_HAVE_compare_and_swap_double)
295 TA_assert(!AO_compare_and_swap_double(&w, 17, 12, 13));
296 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
297 TA_assert(AO_compare_and_swap_double(&w, 0, 12, 13));
298 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
299 TA_assert(!AO_compare_and_swap_double(&w, 13, 12, 33));
300 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
301 TA_assert(!AO_compare_and_swap_double(&w, 1213, 48, 86));
302 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
303 TA_assert(AO_compare_and_swap_double(&w, 12, 17, 42));
304 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
305 TA_assert(AO_compare_and_swap_double(&w, 17, 0, 0));
306 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
307 # else
308 MISSING(AO_compare_and_swap_double);
309 # endif
310 # if defined(AO_HAVE_double_compare_and_swap)
311 old_w.AO_val1 = 4116;
312 old_w.AO_val2 = 2121;
313 new_w.AO_val1 = 8537;
314 new_w.AO_val2 = 6410;
315 TA_assert(!AO_double_compare_and_swap(&w, old_w, new_w));
316 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
317 TA_assert(AO_double_compare_and_swap(&w, w, new_w));
318 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
319 old_w.AO_val1 = new_w.AO_val1;
320 old_w.AO_val2 = 29;
321 new_w.AO_val1 = 820;
322 new_w.AO_val2 = 5917;
323 TA_assert(!AO_double_compare_and_swap(&w, old_w, new_w));
324 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
325 old_w.AO_val1 = 11;
326 old_w.AO_val2 = 6410;
327 new_w.AO_val1 = 3552;
328 new_w.AO_val2 = 1746;
329 TA_assert(!AO_double_compare_and_swap(&w, old_w, new_w));
330 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
331 old_w.AO_val1 = old_w.AO_val2;
332 old_w.AO_val2 = 8537;
333 new_w.AO_val1 = 4116;
334 new_w.AO_val2 = 2121;
335 TA_assert(!AO_double_compare_and_swap(&w, old_w, new_w));
336 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
337 old_w.AO_val1 = old_w.AO_val2;
338 old_w.AO_val2 = 6410;
339 new_w.AO_val1 = 1;
340 TA_assert(AO_double_compare_and_swap(&w, old_w, new_w));
341 TA_assert(w.AO_val1 == 1 && w.AO_val2 == 2121);
342 old_w.AO_val1 = new_w.AO_val1;
343 old_w.AO_val2 = w.AO_val2;
344 new_w.AO_val1--;
345 new_w.AO_val2 = 0;
346 TA_assert(AO_double_compare_and_swap(&w, old_w, new_w));
347 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
348 # else
349 MISSING(AO_double_compare_and_swap);
350 # endif
351 }
352 /*
353 * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved.
354 *
355 * This file is covered by the GNU general public license, version 2.
356 * see COPYING for details.
357 */
358
359 /* Some basic sanity tests. These do not test the barrier semantics. */
360
361 #undef TA_assert
362 #define TA_assert(e) \
363 if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _release)\n", \
364 __FILE__, __LINE__), exit(1); }
365
366 #undef MISSING
367 #define MISSING(name) \
368 printf("Missing: %s\n", #name "_release")
369
test_atomic_release(void)370 void test_atomic_release(void)
371 {
372 AO_t x;
373 unsigned char b;
374 unsigned short s;
375 unsigned int zz;
376 # if defined(AO_HAVE_test_and_set_release)
377 AO_TS_t z = AO_TS_INITIALIZER;
378 # endif
379 # if defined(AO_HAVE_double_compare_and_swap_release) \
380 || defined(AO_HAVE_double_load_release) \
381 || defined(AO_HAVE_double_store_release)
382 AO_double_t old_w;
383 AO_double_t new_w;
384 # endif
385 # if defined(AO_HAVE_compare_and_swap_double_release) \
386 || defined(AO_HAVE_compare_double_and_swap_double_release) \
387 || defined(AO_HAVE_double_compare_and_swap_release)
388 AO_double_t w;
389 w.AO_val1 = 0;
390 w.AO_val2 = 0;
391 # endif
392
393 # if defined(AO_HAVE_nop_release)
394 AO_nop_release();
395 # elif !defined(AO_HAVE_nop) || !defined(AO_HAVE_nop_full) \
396 || !defined(AO_HAVE_nop_read) || !defined(AO_HAVE_nop_write)
397 MISSING(AO_nop);
398 # endif
399 # if defined(AO_HAVE_store_release)
400 AO_store_release(&x, 13);
401 TA_assert (x == 13);
402 # else
403 # if !defined(AO_HAVE_store) || !defined(AO_HAVE_store_full) \
404 || !defined(AO_HAVE_store_release) \
405 || !defined(AO_HAVE_store_release_write) \
406 || !defined(AO_HAVE_store_write)
407 MISSING(AO_store);
408 # endif
409 x = 13;
410 # endif
411 # if defined(AO_HAVE_load_release)
412 TA_assert(AO_load_release(&x) == 13);
413 # elif !defined(AO_HAVE_load) || !defined(AO_HAVE_load_acquire) \
414 || !defined(AO_HAVE_load_acquire_read) \
415 || !defined(AO_HAVE_load_dd_acquire_read) \
416 || !defined(AO_HAVE_load_full) || !defined(AO_HAVE_load_read)
417 MISSING(AO_load);
418 # endif
419 # if defined(AO_HAVE_test_and_set_release)
420 assert(AO_test_and_set_release(&z) == AO_TS_CLEAR);
421 assert(AO_test_and_set_release(&z) == AO_TS_SET);
422 assert(AO_test_and_set_release(&z) == AO_TS_SET);
423 AO_CLEAR(&z);
424 # else
425 MISSING(AO_test_and_set);
426 # endif
427 # if defined(AO_HAVE_fetch_and_add_release)
428 TA_assert(AO_fetch_and_add_release(&x, 42) == 13);
429 TA_assert(AO_fetch_and_add_release(&x, (AO_t)(-42)) == 55);
430 # else
431 MISSING(AO_fetch_and_add);
432 # endif
433 # if defined(AO_HAVE_fetch_and_add1_release)
434 TA_assert(AO_fetch_and_add1_release(&x) == 13);
435 # else
436 MISSING(AO_fetch_and_add1);
437 ++x;
438 # endif
439 # if defined(AO_HAVE_fetch_and_sub1_release)
440 TA_assert(AO_fetch_and_sub1_release(&x) == 14);
441 # else
442 MISSING(AO_fetch_and_sub1);
443 --x;
444 # endif
445 # if defined(AO_HAVE_short_store_release)
446 AO_short_store_release(&s, 13);
447 # else
448 # if !defined(AO_HAVE_short_store) || !defined(AO_HAVE_short_store_full) \
449 || !defined(AO_HAVE_short_store_release) \
450 || !defined(AO_HAVE_short_store_release_write) \
451 || !defined(AO_HAVE_short_store_write)
452 MISSING(AO_short_store);
453 # endif
454 s = 13;
455 # endif
456 # if defined(AO_HAVE_short_load_release)
457 TA_assert(AO_short_load(&s) == 13);
458 # elif !defined(AO_HAVE_short_load) || !defined(AO_HAVE_short_load_acquire) \
459 || !defined(AO_HAVE_short_load_acquire_read) \
460 || !defined(AO_HAVE_short_load_dd_acquire_read) \
461 || !defined(AO_HAVE_short_load_full) \
462 || !defined(AO_HAVE_short_load_read)
463 MISSING(AO_short_load);
464 # endif
465 # if defined(AO_HAVE_short_fetch_and_add_release)
466 TA_assert(AO_short_fetch_and_add_release(&s, 42) == 13);
467 TA_assert(AO_short_fetch_and_add_release(&s, (unsigned short)-42) == 55);
468 # else
469 MISSING(AO_short_fetch_and_add);
470 # endif
471 # if defined(AO_HAVE_short_fetch_and_add1_release)
472 TA_assert(AO_short_fetch_and_add1_release(&s) == 13);
473 # else
474 MISSING(AO_short_fetch_and_add1);
475 ++s;
476 # endif
477 # if defined(AO_HAVE_short_fetch_and_sub1_release)
478 TA_assert(AO_short_fetch_and_sub1_release(&s) == 14);
479 # else
480 MISSING(AO_short_fetch_and_sub1);
481 --s;
482 # endif
483 # if defined(AO_HAVE_char_store_release)
484 AO_char_store_release(&b, 13);
485 # else
486 # if !defined(AO_HAVE_char_store) || !defined(AO_HAVE_char_store_full) \
487 || !defined(AO_HAVE_char_store_release) \
488 || !defined(AO_HAVE_char_store_release_write) \
489 || !defined(AO_HAVE_char_store_write)
490 MISSING(AO_char_store);
491 # endif
492 b = 13;
493 # endif
494 # if defined(AO_HAVE_char_load_release)
495 TA_assert(AO_char_load(&b) == 13);
496 # elif !defined(AO_HAVE_char_load) || !defined(AO_HAVE_char_load_acquire) \
497 || !defined(AO_HAVE_char_load_acquire_read) \
498 || !defined(AO_HAVE_char_load_dd_acquire_read) \
499 || !defined(AO_HAVE_char_load_full) || !defined(AO_HAVE_char_load_read)
500 MISSING(AO_char_load);
501 # endif
502 # if defined(AO_HAVE_char_fetch_and_add_release)
503 TA_assert(AO_char_fetch_and_add_release(&b, 42) == 13);
504 TA_assert(AO_char_fetch_and_add_release(&b, (unsigned char)-42) == 55);
505 # else
506 MISSING(AO_char_fetch_and_add);
507 # endif
508 # if defined(AO_HAVE_char_fetch_and_add1_release)
509 TA_assert(AO_char_fetch_and_add1_release(&b) == 13);
510 # else
511 MISSING(AO_char_fetch_and_add1);
512 ++b;
513 # endif
514 # if defined(AO_HAVE_char_fetch_and_sub1_release)
515 TA_assert(AO_char_fetch_and_sub1_release(&b) == 14);
516 # else
517 MISSING(AO_char_fetch_and_sub1);
518 --b;
519 # endif
520 # if defined(AO_HAVE_int_store_release)
521 AO_int_store_release(&zz, 13);
522 # else
523 # if !defined(AO_HAVE_int_store) || !defined(AO_HAVE_int_store_full) \
524 || !defined(AO_HAVE_int_store_release) \
525 || !defined(AO_HAVE_int_store_release_write) \
526 || !defined(AO_HAVE_int_store_write)
527 MISSING(AO_int_store);
528 # endif
529 zz = 13;
530 # endif
531 # if defined(AO_HAVE_int_load_release)
532 TA_assert(AO_int_load(&zz) == 13);
533 # elif !defined(AO_HAVE_int_load) || !defined(AO_HAVE_int_load_acquire) \
534 || !defined(AO_HAVE_int_load_acquire_read) \
535 || !defined(AO_HAVE_int_load_dd_acquire_read) \
536 || !defined(AO_HAVE_int_load_full) || !defined(AO_HAVE_int_load_read)
537 MISSING(AO_int_load);
538 # endif
539 # if defined(AO_HAVE_int_fetch_and_add_release)
540 TA_assert(AO_int_fetch_and_add_release(&zz, 42) == 13);
541 TA_assert(AO_int_fetch_and_add_release(&zz, (unsigned int)-42) == 55);
542 # else
543 MISSING(AO_int_fetch_and_add);
544 # endif
545 # if defined(AO_HAVE_int_fetch_and_add1_release)
546 TA_assert(AO_int_fetch_and_add1_release(&zz) == 13);
547 # else
548 MISSING(AO_int_fetch_and_add1);
549 ++zz;
550 # endif
551 # if defined(AO_HAVE_int_fetch_and_sub1_release)
552 TA_assert(AO_int_fetch_and_sub1_release(&zz) == 14);
553 # else
554 MISSING(AO_int_fetch_and_sub1);
555 --zz;
556 # endif
557 # if defined(AO_HAVE_compare_and_swap_release)
558 TA_assert(!AO_compare_and_swap_release(&x, 14, 42));
559 TA_assert(x == 13);
560 TA_assert(AO_compare_and_swap_release(&x, 13, 42));
561 TA_assert(x == 42);
562 # else
563 MISSING(AO_compare_and_swap);
564 if (x == 13) x = 42;
565 # endif
566 # if defined(AO_HAVE_or_release)
567 AO_or_release(&x, 66);
568 TA_assert(x == 106);
569 # else
570 MISSING(AO_or);
571 x |= 66;
572 # endif
573 # if defined(AO_HAVE_xor_release)
574 AO_xor_release(&x, 181);
575 TA_assert(x == 223);
576 # else
577 MISSING(AO_xor);
578 x ^= 181;
579 # endif
580 # if defined(AO_HAVE_and_release)
581 AO_and_release(&x, 57);
582 TA_assert(x == 25);
583 # else
584 MISSING(AO_and);
585 x &= 57;
586 # endif
587 # if defined(AO_HAVE_fetch_compare_and_swap_release)
588 TA_assert(AO_fetch_compare_and_swap_release(&x, 14, 117) == 25);
589 TA_assert(x == 25);
590 TA_assert(AO_fetch_compare_and_swap_release(&x, 25, 117) == 25);
591 TA_assert(x == 117);
592 # else
593 MISSING(AO_fetch_compare_and_swap);
594 if (x == 25) x = 117;
595 # endif
596 # if defined(AO_HAVE_double_load_release)
597 old_w.AO_val1 = 3316;
598 old_w.AO_val2 = 2921;
599 new_w = AO_double_load_release(&old_w);
600 TA_assert(new_w.AO_val1 == 3316 && new_w.AO_val2 == 2921);
601 # elif !defined(AO_HAVE_double_load) \
602 || !defined(AO_HAVE_double_load_acquire) \
603 || !defined(AO_HAVE_double_load_acquire_read) \
604 || !defined(AO_HAVE_double_load_dd_acquire_read) \
605 || !defined(AO_HAVE_double_load_full) \
606 || !defined(AO_HAVE_double_load_read)
607 MISSING(AO_double_load);
608 # endif
609 # if defined(AO_HAVE_double_store_release)
610 new_w.AO_val1 = 1375;
611 new_w.AO_val2 = 8243;
612 AO_double_store_release(&old_w, new_w);
613 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
614 AO_double_store_release(&old_w, new_w);
615 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
616 new_w.AO_val1 ^= old_w.AO_val1;
617 new_w.AO_val2 ^= old_w.AO_val2;
618 AO_double_store_release(&old_w, new_w);
619 TA_assert(old_w.AO_val1 == 0 && old_w.AO_val2 == 0);
620 # elif !defined(AO_HAVE_double_store) \
621 || !defined(AO_HAVE_double_store_full) \
622 || !defined(AO_HAVE_double_store_release) \
623 || !defined(AO_HAVE_double_store_release_write) \
624 || !defined(AO_HAVE_double_store_write)
625 MISSING(AO_double_store);
626 # endif
627 # if defined(AO_HAVE_compare_double_and_swap_double_release)
628 TA_assert(!AO_compare_double_and_swap_double_release(&w, 17, 42, 12, 13));
629 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
630 TA_assert(AO_compare_double_and_swap_double_release(&w, 0, 0, 12, 13));
631 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
632 TA_assert(!AO_compare_double_and_swap_double_release(&w, 12, 14, 64, 33));
633 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
634 TA_assert(!AO_compare_double_and_swap_double_release(&w, 11, 13, 85, 82));
635 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
636 TA_assert(!AO_compare_double_and_swap_double_release(&w, 13, 12, 17, 42));
637 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
638 TA_assert(AO_compare_double_and_swap_double_release(&w, 12, 13, 17, 42));
639 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
640 TA_assert(AO_compare_double_and_swap_double_release(&w, 17, 42, 0, 0));
641 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
642 # else
643 MISSING(AO_compare_double_and_swap_double);
644 # endif
645 # if defined(AO_HAVE_compare_and_swap_double_release)
646 TA_assert(!AO_compare_and_swap_double_release(&w, 17, 12, 13));
647 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
648 TA_assert(AO_compare_and_swap_double_release(&w, 0, 12, 13));
649 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
650 TA_assert(!AO_compare_and_swap_double_release(&w, 13, 12, 33));
651 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
652 TA_assert(!AO_compare_and_swap_double_release(&w, 1213, 48, 86));
653 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
654 TA_assert(AO_compare_and_swap_double_release(&w, 12, 17, 42));
655 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
656 TA_assert(AO_compare_and_swap_double_release(&w, 17, 0, 0));
657 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
658 # else
659 MISSING(AO_compare_and_swap_double);
660 # endif
661 # if defined(AO_HAVE_double_compare_and_swap_release)
662 old_w.AO_val1 = 4116;
663 old_w.AO_val2 = 2121;
664 new_w.AO_val1 = 8537;
665 new_w.AO_val2 = 6410;
666 TA_assert(!AO_double_compare_and_swap_release(&w, old_w, new_w));
667 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
668 TA_assert(AO_double_compare_and_swap_release(&w, w, new_w));
669 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
670 old_w.AO_val1 = new_w.AO_val1;
671 old_w.AO_val2 = 29;
672 new_w.AO_val1 = 820;
673 new_w.AO_val2 = 5917;
674 TA_assert(!AO_double_compare_and_swap_release(&w, old_w, new_w));
675 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
676 old_w.AO_val1 = 11;
677 old_w.AO_val2 = 6410;
678 new_w.AO_val1 = 3552;
679 new_w.AO_val2 = 1746;
680 TA_assert(!AO_double_compare_and_swap_release(&w, old_w, new_w));
681 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
682 old_w.AO_val1 = old_w.AO_val2;
683 old_w.AO_val2 = 8537;
684 new_w.AO_val1 = 4116;
685 new_w.AO_val2 = 2121;
686 TA_assert(!AO_double_compare_and_swap_release(&w, old_w, new_w));
687 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
688 old_w.AO_val1 = old_w.AO_val2;
689 old_w.AO_val2 = 6410;
690 new_w.AO_val1 = 1;
691 TA_assert(AO_double_compare_and_swap_release(&w, old_w, new_w));
692 TA_assert(w.AO_val1 == 1 && w.AO_val2 == 2121);
693 old_w.AO_val1 = new_w.AO_val1;
694 old_w.AO_val2 = w.AO_val2;
695 new_w.AO_val1--;
696 new_w.AO_val2 = 0;
697 TA_assert(AO_double_compare_and_swap_release(&w, old_w, new_w));
698 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
699 # else
700 MISSING(AO_double_compare_and_swap);
701 # endif
702 }
703 /*
704 * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved.
705 *
706 * This file is covered by the GNU general public license, version 2.
707 * see COPYING for details.
708 */
709
710 /* Some basic sanity tests. These do not test the barrier semantics. */
711
712 #undef TA_assert
713 #define TA_assert(e) \
714 if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _acquire)\n", \
715 __FILE__, __LINE__), exit(1); }
716
717 #undef MISSING
718 #define MISSING(name) \
719 printf("Missing: %s\n", #name "_acquire")
720
test_atomic_acquire(void)721 void test_atomic_acquire(void)
722 {
723 AO_t x;
724 unsigned char b;
725 unsigned short s;
726 unsigned int zz;
727 # if defined(AO_HAVE_test_and_set_acquire)
728 AO_TS_t z = AO_TS_INITIALIZER;
729 # endif
730 # if defined(AO_HAVE_double_compare_and_swap_acquire) \
731 || defined(AO_HAVE_double_load_acquire) \
732 || defined(AO_HAVE_double_store_acquire)
733 AO_double_t old_w;
734 AO_double_t new_w;
735 # endif
736 # if defined(AO_HAVE_compare_and_swap_double_acquire) \
737 || defined(AO_HAVE_compare_double_and_swap_double_acquire) \
738 || defined(AO_HAVE_double_compare_and_swap_acquire)
739 AO_double_t w;
740 w.AO_val1 = 0;
741 w.AO_val2 = 0;
742 # endif
743
744 # if defined(AO_HAVE_nop_acquire)
745 AO_nop_acquire();
746 # elif !defined(AO_HAVE_nop) || !defined(AO_HAVE_nop_full) \
747 || !defined(AO_HAVE_nop_read) || !defined(AO_HAVE_nop_write)
748 MISSING(AO_nop);
749 # endif
750 # if defined(AO_HAVE_store_acquire)
751 AO_store_acquire(&x, 13);
752 TA_assert (x == 13);
753 # else
754 # if !defined(AO_HAVE_store) || !defined(AO_HAVE_store_full) \
755 || !defined(AO_HAVE_store_release) \
756 || !defined(AO_HAVE_store_release_write) \
757 || !defined(AO_HAVE_store_write)
758 MISSING(AO_store);
759 # endif
760 x = 13;
761 # endif
762 # if defined(AO_HAVE_load_acquire)
763 TA_assert(AO_load_acquire(&x) == 13);
764 # elif !defined(AO_HAVE_load) || !defined(AO_HAVE_load_acquire) \
765 || !defined(AO_HAVE_load_acquire_read) \
766 || !defined(AO_HAVE_load_dd_acquire_read) \
767 || !defined(AO_HAVE_load_full) || !defined(AO_HAVE_load_read)
768 MISSING(AO_load);
769 # endif
770 # if defined(AO_HAVE_test_and_set_acquire)
771 assert(AO_test_and_set_acquire(&z) == AO_TS_CLEAR);
772 assert(AO_test_and_set_acquire(&z) == AO_TS_SET);
773 assert(AO_test_and_set_acquire(&z) == AO_TS_SET);
774 AO_CLEAR(&z);
775 # else
776 MISSING(AO_test_and_set);
777 # endif
778 # if defined(AO_HAVE_fetch_and_add_acquire)
779 TA_assert(AO_fetch_and_add_acquire(&x, 42) == 13);
780 TA_assert(AO_fetch_and_add_acquire(&x, (AO_t)(-42)) == 55);
781 # else
782 MISSING(AO_fetch_and_add);
783 # endif
784 # if defined(AO_HAVE_fetch_and_add1_acquire)
785 TA_assert(AO_fetch_and_add1_acquire(&x) == 13);
786 # else
787 MISSING(AO_fetch_and_add1);
788 ++x;
789 # endif
790 # if defined(AO_HAVE_fetch_and_sub1_acquire)
791 TA_assert(AO_fetch_and_sub1_acquire(&x) == 14);
792 # else
793 MISSING(AO_fetch_and_sub1);
794 --x;
795 # endif
796 # if defined(AO_HAVE_short_store_acquire)
797 AO_short_store_acquire(&s, 13);
798 # else
799 # if !defined(AO_HAVE_short_store) || !defined(AO_HAVE_short_store_full) \
800 || !defined(AO_HAVE_short_store_release) \
801 || !defined(AO_HAVE_short_store_release_write) \
802 || !defined(AO_HAVE_short_store_write)
803 MISSING(AO_short_store);
804 # endif
805 s = 13;
806 # endif
807 # if defined(AO_HAVE_short_load_acquire)
808 TA_assert(AO_short_load(&s) == 13);
809 # elif !defined(AO_HAVE_short_load) || !defined(AO_HAVE_short_load_acquire) \
810 || !defined(AO_HAVE_short_load_acquire_read) \
811 || !defined(AO_HAVE_short_load_dd_acquire_read) \
812 || !defined(AO_HAVE_short_load_full) \
813 || !defined(AO_HAVE_short_load_read)
814 MISSING(AO_short_load);
815 # endif
816 # if defined(AO_HAVE_short_fetch_and_add_acquire)
817 TA_assert(AO_short_fetch_and_add_acquire(&s, 42) == 13);
818 TA_assert(AO_short_fetch_and_add_acquire(&s, (unsigned short)-42) == 55);
819 # else
820 MISSING(AO_short_fetch_and_add);
821 # endif
822 # if defined(AO_HAVE_short_fetch_and_add1_acquire)
823 TA_assert(AO_short_fetch_and_add1_acquire(&s) == 13);
824 # else
825 MISSING(AO_short_fetch_and_add1);
826 ++s;
827 # endif
828 # if defined(AO_HAVE_short_fetch_and_sub1_acquire)
829 TA_assert(AO_short_fetch_and_sub1_acquire(&s) == 14);
830 # else
831 MISSING(AO_short_fetch_and_sub1);
832 --s;
833 # endif
834 # if defined(AO_HAVE_char_store_acquire)
835 AO_char_store_acquire(&b, 13);
836 # else
837 # if !defined(AO_HAVE_char_store) || !defined(AO_HAVE_char_store_full) \
838 || !defined(AO_HAVE_char_store_release) \
839 || !defined(AO_HAVE_char_store_release_write) \
840 || !defined(AO_HAVE_char_store_write)
841 MISSING(AO_char_store);
842 # endif
843 b = 13;
844 # endif
845 # if defined(AO_HAVE_char_load_acquire)
846 TA_assert(AO_char_load(&b) == 13);
847 # elif !defined(AO_HAVE_char_load) || !defined(AO_HAVE_char_load_acquire) \
848 || !defined(AO_HAVE_char_load_acquire_read) \
849 || !defined(AO_HAVE_char_load_dd_acquire_read) \
850 || !defined(AO_HAVE_char_load_full) || !defined(AO_HAVE_char_load_read)
851 MISSING(AO_char_load);
852 # endif
853 # if defined(AO_HAVE_char_fetch_and_add_acquire)
854 TA_assert(AO_char_fetch_and_add_acquire(&b, 42) == 13);
855 TA_assert(AO_char_fetch_and_add_acquire(&b, (unsigned char)-42) == 55);
856 # else
857 MISSING(AO_char_fetch_and_add);
858 # endif
859 # if defined(AO_HAVE_char_fetch_and_add1_acquire)
860 TA_assert(AO_char_fetch_and_add1_acquire(&b) == 13);
861 # else
862 MISSING(AO_char_fetch_and_add1);
863 ++b;
864 # endif
865 # if defined(AO_HAVE_char_fetch_and_sub1_acquire)
866 TA_assert(AO_char_fetch_and_sub1_acquire(&b) == 14);
867 # else
868 MISSING(AO_char_fetch_and_sub1);
869 --b;
870 # endif
871 # if defined(AO_HAVE_int_store_acquire)
872 AO_int_store_acquire(&zz, 13);
873 # else
874 # if !defined(AO_HAVE_int_store) || !defined(AO_HAVE_int_store_full) \
875 || !defined(AO_HAVE_int_store_release) \
876 || !defined(AO_HAVE_int_store_release_write) \
877 || !defined(AO_HAVE_int_store_write)
878 MISSING(AO_int_store);
879 # endif
880 zz = 13;
881 # endif
882 # if defined(AO_HAVE_int_load_acquire)
883 TA_assert(AO_int_load(&zz) == 13);
884 # elif !defined(AO_HAVE_int_load) || !defined(AO_HAVE_int_load_acquire) \
885 || !defined(AO_HAVE_int_load_acquire_read) \
886 || !defined(AO_HAVE_int_load_dd_acquire_read) \
887 || !defined(AO_HAVE_int_load_full) || !defined(AO_HAVE_int_load_read)
888 MISSING(AO_int_load);
889 # endif
890 # if defined(AO_HAVE_int_fetch_and_add_acquire)
891 TA_assert(AO_int_fetch_and_add_acquire(&zz, 42) == 13);
892 TA_assert(AO_int_fetch_and_add_acquire(&zz, (unsigned int)-42) == 55);
893 # else
894 MISSING(AO_int_fetch_and_add);
895 # endif
896 # if defined(AO_HAVE_int_fetch_and_add1_acquire)
897 TA_assert(AO_int_fetch_and_add1_acquire(&zz) == 13);
898 # else
899 MISSING(AO_int_fetch_and_add1);
900 ++zz;
901 # endif
902 # if defined(AO_HAVE_int_fetch_and_sub1_acquire)
903 TA_assert(AO_int_fetch_and_sub1_acquire(&zz) == 14);
904 # else
905 MISSING(AO_int_fetch_and_sub1);
906 --zz;
907 # endif
908 # if defined(AO_HAVE_compare_and_swap_acquire)
909 TA_assert(!AO_compare_and_swap_acquire(&x, 14, 42));
910 TA_assert(x == 13);
911 TA_assert(AO_compare_and_swap_acquire(&x, 13, 42));
912 TA_assert(x == 42);
913 # else
914 MISSING(AO_compare_and_swap);
915 if (x == 13) x = 42;
916 # endif
917 # if defined(AO_HAVE_or_acquire)
918 AO_or_acquire(&x, 66);
919 TA_assert(x == 106);
920 # else
921 MISSING(AO_or);
922 x |= 66;
923 # endif
924 # if defined(AO_HAVE_xor_acquire)
925 AO_xor_acquire(&x, 181);
926 TA_assert(x == 223);
927 # else
928 MISSING(AO_xor);
929 x ^= 181;
930 # endif
931 # if defined(AO_HAVE_and_acquire)
932 AO_and_acquire(&x, 57);
933 TA_assert(x == 25);
934 # else
935 MISSING(AO_and);
936 x &= 57;
937 # endif
938 # if defined(AO_HAVE_fetch_compare_and_swap_acquire)
939 TA_assert(AO_fetch_compare_and_swap_acquire(&x, 14, 117) == 25);
940 TA_assert(x == 25);
941 TA_assert(AO_fetch_compare_and_swap_acquire(&x, 25, 117) == 25);
942 TA_assert(x == 117);
943 # else
944 MISSING(AO_fetch_compare_and_swap);
945 if (x == 25) x = 117;
946 # endif
947 # if defined(AO_HAVE_double_load_acquire)
948 old_w.AO_val1 = 3316;
949 old_w.AO_val2 = 2921;
950 new_w = AO_double_load_acquire(&old_w);
951 TA_assert(new_w.AO_val1 == 3316 && new_w.AO_val2 == 2921);
952 # elif !defined(AO_HAVE_double_load) \
953 || !defined(AO_HAVE_double_load_acquire) \
954 || !defined(AO_HAVE_double_load_acquire_read) \
955 || !defined(AO_HAVE_double_load_dd_acquire_read) \
956 || !defined(AO_HAVE_double_load_full) \
957 || !defined(AO_HAVE_double_load_read)
958 MISSING(AO_double_load);
959 # endif
960 # if defined(AO_HAVE_double_store_acquire)
961 new_w.AO_val1 = 1375;
962 new_w.AO_val2 = 8243;
963 AO_double_store_acquire(&old_w, new_w);
964 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
965 AO_double_store_acquire(&old_w, new_w);
966 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
967 new_w.AO_val1 ^= old_w.AO_val1;
968 new_w.AO_val2 ^= old_w.AO_val2;
969 AO_double_store_acquire(&old_w, new_w);
970 TA_assert(old_w.AO_val1 == 0 && old_w.AO_val2 == 0);
971 # elif !defined(AO_HAVE_double_store) \
972 || !defined(AO_HAVE_double_store_full) \
973 || !defined(AO_HAVE_double_store_release) \
974 || !defined(AO_HAVE_double_store_release_write) \
975 || !defined(AO_HAVE_double_store_write)
976 MISSING(AO_double_store);
977 # endif
978 # if defined(AO_HAVE_compare_double_and_swap_double_acquire)
979 TA_assert(!AO_compare_double_and_swap_double_acquire(&w, 17, 42, 12, 13));
980 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
981 TA_assert(AO_compare_double_and_swap_double_acquire(&w, 0, 0, 12, 13));
982 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
983 TA_assert(!AO_compare_double_and_swap_double_acquire(&w, 12, 14, 64, 33));
984 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
985 TA_assert(!AO_compare_double_and_swap_double_acquire(&w, 11, 13, 85, 82));
986 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
987 TA_assert(!AO_compare_double_and_swap_double_acquire(&w, 13, 12, 17, 42));
988 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
989 TA_assert(AO_compare_double_and_swap_double_acquire(&w, 12, 13, 17, 42));
990 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
991 TA_assert(AO_compare_double_and_swap_double_acquire(&w, 17, 42, 0, 0));
992 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
993 # else
994 MISSING(AO_compare_double_and_swap_double);
995 # endif
996 # if defined(AO_HAVE_compare_and_swap_double_acquire)
997 TA_assert(!AO_compare_and_swap_double_acquire(&w, 17, 12, 13));
998 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
999 TA_assert(AO_compare_and_swap_double_acquire(&w, 0, 12, 13));
1000 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1001 TA_assert(!AO_compare_and_swap_double_acquire(&w, 13, 12, 33));
1002 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1003 TA_assert(!AO_compare_and_swap_double_acquire(&w, 1213, 48, 86));
1004 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1005 TA_assert(AO_compare_and_swap_double_acquire(&w, 12, 17, 42));
1006 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1007 TA_assert(AO_compare_and_swap_double_acquire(&w, 17, 0, 0));
1008 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1009 # else
1010 MISSING(AO_compare_and_swap_double);
1011 # endif
1012 # if defined(AO_HAVE_double_compare_and_swap_acquire)
1013 old_w.AO_val1 = 4116;
1014 old_w.AO_val2 = 2121;
1015 new_w.AO_val1 = 8537;
1016 new_w.AO_val2 = 6410;
1017 TA_assert(!AO_double_compare_and_swap_acquire(&w, old_w, new_w));
1018 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1019 TA_assert(AO_double_compare_and_swap_acquire(&w, w, new_w));
1020 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1021 old_w.AO_val1 = new_w.AO_val1;
1022 old_w.AO_val2 = 29;
1023 new_w.AO_val1 = 820;
1024 new_w.AO_val2 = 5917;
1025 TA_assert(!AO_double_compare_and_swap_acquire(&w, old_w, new_w));
1026 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1027 old_w.AO_val1 = 11;
1028 old_w.AO_val2 = 6410;
1029 new_w.AO_val1 = 3552;
1030 new_w.AO_val2 = 1746;
1031 TA_assert(!AO_double_compare_and_swap_acquire(&w, old_w, new_w));
1032 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1033 old_w.AO_val1 = old_w.AO_val2;
1034 old_w.AO_val2 = 8537;
1035 new_w.AO_val1 = 4116;
1036 new_w.AO_val2 = 2121;
1037 TA_assert(!AO_double_compare_and_swap_acquire(&w, old_w, new_w));
1038 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1039 old_w.AO_val1 = old_w.AO_val2;
1040 old_w.AO_val2 = 6410;
1041 new_w.AO_val1 = 1;
1042 TA_assert(AO_double_compare_and_swap_acquire(&w, old_w, new_w));
1043 TA_assert(w.AO_val1 == 1 && w.AO_val2 == 2121);
1044 old_w.AO_val1 = new_w.AO_val1;
1045 old_w.AO_val2 = w.AO_val2;
1046 new_w.AO_val1--;
1047 new_w.AO_val2 = 0;
1048 TA_assert(AO_double_compare_and_swap_acquire(&w, old_w, new_w));
1049 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1050 # else
1051 MISSING(AO_double_compare_and_swap);
1052 # endif
1053 }
1054 /*
1055 * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved.
1056 *
1057 * This file is covered by the GNU general public license, version 2.
1058 * see COPYING for details.
1059 */
1060
1061 /* Some basic sanity tests. These do not test the barrier semantics. */
1062
1063 #undef TA_assert
1064 #define TA_assert(e) \
1065 if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _read)\n", \
1066 __FILE__, __LINE__), exit(1); }
1067
1068 #undef MISSING
1069 #define MISSING(name) \
1070 printf("Missing: %s\n", #name "_read")
1071
test_atomic_read(void)1072 void test_atomic_read(void)
1073 {
1074 AO_t x;
1075 unsigned char b;
1076 unsigned short s;
1077 unsigned int zz;
1078 # if defined(AO_HAVE_test_and_set_read)
1079 AO_TS_t z = AO_TS_INITIALIZER;
1080 # endif
1081 # if defined(AO_HAVE_double_compare_and_swap_read) \
1082 || defined(AO_HAVE_double_load_read) \
1083 || defined(AO_HAVE_double_store_read)
1084 AO_double_t old_w;
1085 AO_double_t new_w;
1086 # endif
1087 # if defined(AO_HAVE_compare_and_swap_double_read) \
1088 || defined(AO_HAVE_compare_double_and_swap_double_read) \
1089 || defined(AO_HAVE_double_compare_and_swap_read)
1090 AO_double_t w;
1091 w.AO_val1 = 0;
1092 w.AO_val2 = 0;
1093 # endif
1094
1095 # if defined(AO_HAVE_nop_read)
1096 AO_nop_read();
1097 # elif !defined(AO_HAVE_nop) || !defined(AO_HAVE_nop_full) \
1098 || !defined(AO_HAVE_nop_read) || !defined(AO_HAVE_nop_write)
1099 MISSING(AO_nop);
1100 # endif
1101 # if defined(AO_HAVE_store_read)
1102 AO_store_read(&x, 13);
1103 TA_assert (x == 13);
1104 # else
1105 # if !defined(AO_HAVE_store) || !defined(AO_HAVE_store_full) \
1106 || !defined(AO_HAVE_store_release) \
1107 || !defined(AO_HAVE_store_release_write) \
1108 || !defined(AO_HAVE_store_write)
1109 MISSING(AO_store);
1110 # endif
1111 x = 13;
1112 # endif
1113 # if defined(AO_HAVE_load_read)
1114 TA_assert(AO_load_read(&x) == 13);
1115 # elif !defined(AO_HAVE_load) || !defined(AO_HAVE_load_acquire) \
1116 || !defined(AO_HAVE_load_acquire_read) \
1117 || !defined(AO_HAVE_load_dd_acquire_read) \
1118 || !defined(AO_HAVE_load_full) || !defined(AO_HAVE_load_read)
1119 MISSING(AO_load);
1120 # endif
1121 # if defined(AO_HAVE_test_and_set_read)
1122 assert(AO_test_and_set_read(&z) == AO_TS_CLEAR);
1123 assert(AO_test_and_set_read(&z) == AO_TS_SET);
1124 assert(AO_test_and_set_read(&z) == AO_TS_SET);
1125 AO_CLEAR(&z);
1126 # else
1127 MISSING(AO_test_and_set);
1128 # endif
1129 # if defined(AO_HAVE_fetch_and_add_read)
1130 TA_assert(AO_fetch_and_add_read(&x, 42) == 13);
1131 TA_assert(AO_fetch_and_add_read(&x, (AO_t)(-42)) == 55);
1132 # else
1133 MISSING(AO_fetch_and_add);
1134 # endif
1135 # if defined(AO_HAVE_fetch_and_add1_read)
1136 TA_assert(AO_fetch_and_add1_read(&x) == 13);
1137 # else
1138 MISSING(AO_fetch_and_add1);
1139 ++x;
1140 # endif
1141 # if defined(AO_HAVE_fetch_and_sub1_read)
1142 TA_assert(AO_fetch_and_sub1_read(&x) == 14);
1143 # else
1144 MISSING(AO_fetch_and_sub1);
1145 --x;
1146 # endif
1147 # if defined(AO_HAVE_short_store_read)
1148 AO_short_store_read(&s, 13);
1149 # else
1150 # if !defined(AO_HAVE_short_store) || !defined(AO_HAVE_short_store_full) \
1151 || !defined(AO_HAVE_short_store_release) \
1152 || !defined(AO_HAVE_short_store_release_write) \
1153 || !defined(AO_HAVE_short_store_write)
1154 MISSING(AO_short_store);
1155 # endif
1156 s = 13;
1157 # endif
1158 # if defined(AO_HAVE_short_load_read)
1159 TA_assert(AO_short_load(&s) == 13);
1160 # elif !defined(AO_HAVE_short_load) || !defined(AO_HAVE_short_load_acquire) \
1161 || !defined(AO_HAVE_short_load_acquire_read) \
1162 || !defined(AO_HAVE_short_load_dd_acquire_read) \
1163 || !defined(AO_HAVE_short_load_full) \
1164 || !defined(AO_HAVE_short_load_read)
1165 MISSING(AO_short_load);
1166 # endif
1167 # if defined(AO_HAVE_short_fetch_and_add_read)
1168 TA_assert(AO_short_fetch_and_add_read(&s, 42) == 13);
1169 TA_assert(AO_short_fetch_and_add_read(&s, (unsigned short)-42) == 55);
1170 # else
1171 MISSING(AO_short_fetch_and_add);
1172 # endif
1173 # if defined(AO_HAVE_short_fetch_and_add1_read)
1174 TA_assert(AO_short_fetch_and_add1_read(&s) == 13);
1175 # else
1176 MISSING(AO_short_fetch_and_add1);
1177 ++s;
1178 # endif
1179 # if defined(AO_HAVE_short_fetch_and_sub1_read)
1180 TA_assert(AO_short_fetch_and_sub1_read(&s) == 14);
1181 # else
1182 MISSING(AO_short_fetch_and_sub1);
1183 --s;
1184 # endif
1185 # if defined(AO_HAVE_char_store_read)
1186 AO_char_store_read(&b, 13);
1187 # else
1188 # if !defined(AO_HAVE_char_store) || !defined(AO_HAVE_char_store_full) \
1189 || !defined(AO_HAVE_char_store_release) \
1190 || !defined(AO_HAVE_char_store_release_write) \
1191 || !defined(AO_HAVE_char_store_write)
1192 MISSING(AO_char_store);
1193 # endif
1194 b = 13;
1195 # endif
1196 # if defined(AO_HAVE_char_load_read)
1197 TA_assert(AO_char_load(&b) == 13);
1198 # elif !defined(AO_HAVE_char_load) || !defined(AO_HAVE_char_load_acquire) \
1199 || !defined(AO_HAVE_char_load_acquire_read) \
1200 || !defined(AO_HAVE_char_load_dd_acquire_read) \
1201 || !defined(AO_HAVE_char_load_full) || !defined(AO_HAVE_char_load_read)
1202 MISSING(AO_char_load);
1203 # endif
1204 # if defined(AO_HAVE_char_fetch_and_add_read)
1205 TA_assert(AO_char_fetch_and_add_read(&b, 42) == 13);
1206 TA_assert(AO_char_fetch_and_add_read(&b, (unsigned char)-42) == 55);
1207 # else
1208 MISSING(AO_char_fetch_and_add);
1209 # endif
1210 # if defined(AO_HAVE_char_fetch_and_add1_read)
1211 TA_assert(AO_char_fetch_and_add1_read(&b) == 13);
1212 # else
1213 MISSING(AO_char_fetch_and_add1);
1214 ++b;
1215 # endif
1216 # if defined(AO_HAVE_char_fetch_and_sub1_read)
1217 TA_assert(AO_char_fetch_and_sub1_read(&b) == 14);
1218 # else
1219 MISSING(AO_char_fetch_and_sub1);
1220 --b;
1221 # endif
1222 # if defined(AO_HAVE_int_store_read)
1223 AO_int_store_read(&zz, 13);
1224 # else
1225 # if !defined(AO_HAVE_int_store) || !defined(AO_HAVE_int_store_full) \
1226 || !defined(AO_HAVE_int_store_release) \
1227 || !defined(AO_HAVE_int_store_release_write) \
1228 || !defined(AO_HAVE_int_store_write)
1229 MISSING(AO_int_store);
1230 # endif
1231 zz = 13;
1232 # endif
1233 # if defined(AO_HAVE_int_load_read)
1234 TA_assert(AO_int_load(&zz) == 13);
1235 # elif !defined(AO_HAVE_int_load) || !defined(AO_HAVE_int_load_acquire) \
1236 || !defined(AO_HAVE_int_load_acquire_read) \
1237 || !defined(AO_HAVE_int_load_dd_acquire_read) \
1238 || !defined(AO_HAVE_int_load_full) || !defined(AO_HAVE_int_load_read)
1239 MISSING(AO_int_load);
1240 # endif
1241 # if defined(AO_HAVE_int_fetch_and_add_read)
1242 TA_assert(AO_int_fetch_and_add_read(&zz, 42) == 13);
1243 TA_assert(AO_int_fetch_and_add_read(&zz, (unsigned int)-42) == 55);
1244 # else
1245 MISSING(AO_int_fetch_and_add);
1246 # endif
1247 # if defined(AO_HAVE_int_fetch_and_add1_read)
1248 TA_assert(AO_int_fetch_and_add1_read(&zz) == 13);
1249 # else
1250 MISSING(AO_int_fetch_and_add1);
1251 ++zz;
1252 # endif
1253 # if defined(AO_HAVE_int_fetch_and_sub1_read)
1254 TA_assert(AO_int_fetch_and_sub1_read(&zz) == 14);
1255 # else
1256 MISSING(AO_int_fetch_and_sub1);
1257 --zz;
1258 # endif
1259 # if defined(AO_HAVE_compare_and_swap_read)
1260 TA_assert(!AO_compare_and_swap_read(&x, 14, 42));
1261 TA_assert(x == 13);
1262 TA_assert(AO_compare_and_swap_read(&x, 13, 42));
1263 TA_assert(x == 42);
1264 # else
1265 MISSING(AO_compare_and_swap);
1266 if (x == 13) x = 42;
1267 # endif
1268 # if defined(AO_HAVE_or_read)
1269 AO_or_read(&x, 66);
1270 TA_assert(x == 106);
1271 # else
1272 MISSING(AO_or);
1273 x |= 66;
1274 # endif
1275 # if defined(AO_HAVE_xor_read)
1276 AO_xor_read(&x, 181);
1277 TA_assert(x == 223);
1278 # else
1279 MISSING(AO_xor);
1280 x ^= 181;
1281 # endif
1282 # if defined(AO_HAVE_and_read)
1283 AO_and_read(&x, 57);
1284 TA_assert(x == 25);
1285 # else
1286 MISSING(AO_and);
1287 x &= 57;
1288 # endif
1289 # if defined(AO_HAVE_fetch_compare_and_swap_read)
1290 TA_assert(AO_fetch_compare_and_swap_read(&x, 14, 117) == 25);
1291 TA_assert(x == 25);
1292 TA_assert(AO_fetch_compare_and_swap_read(&x, 25, 117) == 25);
1293 TA_assert(x == 117);
1294 # else
1295 MISSING(AO_fetch_compare_and_swap);
1296 if (x == 25) x = 117;
1297 # endif
1298 # if defined(AO_HAVE_double_load_read)
1299 old_w.AO_val1 = 3316;
1300 old_w.AO_val2 = 2921;
1301 new_w = AO_double_load_read(&old_w);
1302 TA_assert(new_w.AO_val1 == 3316 && new_w.AO_val2 == 2921);
1303 # elif !defined(AO_HAVE_double_load) \
1304 || !defined(AO_HAVE_double_load_acquire) \
1305 || !defined(AO_HAVE_double_load_acquire_read) \
1306 || !defined(AO_HAVE_double_load_dd_acquire_read) \
1307 || !defined(AO_HAVE_double_load_full) \
1308 || !defined(AO_HAVE_double_load_read)
1309 MISSING(AO_double_load);
1310 # endif
1311 # if defined(AO_HAVE_double_store_read)
1312 new_w.AO_val1 = 1375;
1313 new_w.AO_val2 = 8243;
1314 AO_double_store_read(&old_w, new_w);
1315 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
1316 AO_double_store_read(&old_w, new_w);
1317 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
1318 new_w.AO_val1 ^= old_w.AO_val1;
1319 new_w.AO_val2 ^= old_w.AO_val2;
1320 AO_double_store_read(&old_w, new_w);
1321 TA_assert(old_w.AO_val1 == 0 && old_w.AO_val2 == 0);
1322 # elif !defined(AO_HAVE_double_store) \
1323 || !defined(AO_HAVE_double_store_full) \
1324 || !defined(AO_HAVE_double_store_release) \
1325 || !defined(AO_HAVE_double_store_release_write) \
1326 || !defined(AO_HAVE_double_store_write)
1327 MISSING(AO_double_store);
1328 # endif
1329 # if defined(AO_HAVE_compare_double_and_swap_double_read)
1330 TA_assert(!AO_compare_double_and_swap_double_read(&w, 17, 42, 12, 13));
1331 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1332 TA_assert(AO_compare_double_and_swap_double_read(&w, 0, 0, 12, 13));
1333 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1334 TA_assert(!AO_compare_double_and_swap_double_read(&w, 12, 14, 64, 33));
1335 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1336 TA_assert(!AO_compare_double_and_swap_double_read(&w, 11, 13, 85, 82));
1337 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1338 TA_assert(!AO_compare_double_and_swap_double_read(&w, 13, 12, 17, 42));
1339 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1340 TA_assert(AO_compare_double_and_swap_double_read(&w, 12, 13, 17, 42));
1341 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1342 TA_assert(AO_compare_double_and_swap_double_read(&w, 17, 42, 0, 0));
1343 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1344 # else
1345 MISSING(AO_compare_double_and_swap_double);
1346 # endif
1347 # if defined(AO_HAVE_compare_and_swap_double_read)
1348 TA_assert(!AO_compare_and_swap_double_read(&w, 17, 12, 13));
1349 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1350 TA_assert(AO_compare_and_swap_double_read(&w, 0, 12, 13));
1351 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1352 TA_assert(!AO_compare_and_swap_double_read(&w, 13, 12, 33));
1353 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1354 TA_assert(!AO_compare_and_swap_double_read(&w, 1213, 48, 86));
1355 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1356 TA_assert(AO_compare_and_swap_double_read(&w, 12, 17, 42));
1357 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1358 TA_assert(AO_compare_and_swap_double_read(&w, 17, 0, 0));
1359 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1360 # else
1361 MISSING(AO_compare_and_swap_double);
1362 # endif
1363 # if defined(AO_HAVE_double_compare_and_swap_read)
1364 old_w.AO_val1 = 4116;
1365 old_w.AO_val2 = 2121;
1366 new_w.AO_val1 = 8537;
1367 new_w.AO_val2 = 6410;
1368 TA_assert(!AO_double_compare_and_swap_read(&w, old_w, new_w));
1369 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1370 TA_assert(AO_double_compare_and_swap_read(&w, w, new_w));
1371 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1372 old_w.AO_val1 = new_w.AO_val1;
1373 old_w.AO_val2 = 29;
1374 new_w.AO_val1 = 820;
1375 new_w.AO_val2 = 5917;
1376 TA_assert(!AO_double_compare_and_swap_read(&w, old_w, new_w));
1377 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1378 old_w.AO_val1 = 11;
1379 old_w.AO_val2 = 6410;
1380 new_w.AO_val1 = 3552;
1381 new_w.AO_val2 = 1746;
1382 TA_assert(!AO_double_compare_and_swap_read(&w, old_w, new_w));
1383 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1384 old_w.AO_val1 = old_w.AO_val2;
1385 old_w.AO_val2 = 8537;
1386 new_w.AO_val1 = 4116;
1387 new_w.AO_val2 = 2121;
1388 TA_assert(!AO_double_compare_and_swap_read(&w, old_w, new_w));
1389 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1390 old_w.AO_val1 = old_w.AO_val2;
1391 old_w.AO_val2 = 6410;
1392 new_w.AO_val1 = 1;
1393 TA_assert(AO_double_compare_and_swap_read(&w, old_w, new_w));
1394 TA_assert(w.AO_val1 == 1 && w.AO_val2 == 2121);
1395 old_w.AO_val1 = new_w.AO_val1;
1396 old_w.AO_val2 = w.AO_val2;
1397 new_w.AO_val1--;
1398 new_w.AO_val2 = 0;
1399 TA_assert(AO_double_compare_and_swap_read(&w, old_w, new_w));
1400 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1401 # else
1402 MISSING(AO_double_compare_and_swap);
1403 # endif
1404 }
1405 /*
1406 * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved.
1407 *
1408 * This file is covered by the GNU general public license, version 2.
1409 * see COPYING for details.
1410 */
1411
1412 /* Some basic sanity tests. These do not test the barrier semantics. */
1413
1414 #undef TA_assert
1415 #define TA_assert(e) \
1416 if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _write)\n", \
1417 __FILE__, __LINE__), exit(1); }
1418
1419 #undef MISSING
1420 #define MISSING(name) \
1421 printf("Missing: %s\n", #name "_write")
1422
test_atomic_write(void)1423 void test_atomic_write(void)
1424 {
1425 AO_t x;
1426 unsigned char b;
1427 unsigned short s;
1428 unsigned int zz;
1429 # if defined(AO_HAVE_test_and_set_write)
1430 AO_TS_t z = AO_TS_INITIALIZER;
1431 # endif
1432 # if defined(AO_HAVE_double_compare_and_swap_write) \
1433 || defined(AO_HAVE_double_load_write) \
1434 || defined(AO_HAVE_double_store_write)
1435 AO_double_t old_w;
1436 AO_double_t new_w;
1437 # endif
1438 # if defined(AO_HAVE_compare_and_swap_double_write) \
1439 || defined(AO_HAVE_compare_double_and_swap_double_write) \
1440 || defined(AO_HAVE_double_compare_and_swap_write)
1441 AO_double_t w;
1442 w.AO_val1 = 0;
1443 w.AO_val2 = 0;
1444 # endif
1445
1446 # if defined(AO_HAVE_nop_write)
1447 AO_nop_write();
1448 # elif !defined(AO_HAVE_nop) || !defined(AO_HAVE_nop_full) \
1449 || !defined(AO_HAVE_nop_read) || !defined(AO_HAVE_nop_write)
1450 MISSING(AO_nop);
1451 # endif
1452 # if defined(AO_HAVE_store_write)
1453 AO_store_write(&x, 13);
1454 TA_assert (x == 13);
1455 # else
1456 # if !defined(AO_HAVE_store) || !defined(AO_HAVE_store_full) \
1457 || !defined(AO_HAVE_store_release) \
1458 || !defined(AO_HAVE_store_release_write) \
1459 || !defined(AO_HAVE_store_write)
1460 MISSING(AO_store);
1461 # endif
1462 x = 13;
1463 # endif
1464 # if defined(AO_HAVE_load_write)
1465 TA_assert(AO_load_write(&x) == 13);
1466 # elif !defined(AO_HAVE_load) || !defined(AO_HAVE_load_acquire) \
1467 || !defined(AO_HAVE_load_acquire_read) \
1468 || !defined(AO_HAVE_load_dd_acquire_read) \
1469 || !defined(AO_HAVE_load_full) || !defined(AO_HAVE_load_read)
1470 MISSING(AO_load);
1471 # endif
1472 # if defined(AO_HAVE_test_and_set_write)
1473 assert(AO_test_and_set_write(&z) == AO_TS_CLEAR);
1474 assert(AO_test_and_set_write(&z) == AO_TS_SET);
1475 assert(AO_test_and_set_write(&z) == AO_TS_SET);
1476 AO_CLEAR(&z);
1477 # else
1478 MISSING(AO_test_and_set);
1479 # endif
1480 # if defined(AO_HAVE_fetch_and_add_write)
1481 TA_assert(AO_fetch_and_add_write(&x, 42) == 13);
1482 TA_assert(AO_fetch_and_add_write(&x, (AO_t)(-42)) == 55);
1483 # else
1484 MISSING(AO_fetch_and_add);
1485 # endif
1486 # if defined(AO_HAVE_fetch_and_add1_write)
1487 TA_assert(AO_fetch_and_add1_write(&x) == 13);
1488 # else
1489 MISSING(AO_fetch_and_add1);
1490 ++x;
1491 # endif
1492 # if defined(AO_HAVE_fetch_and_sub1_write)
1493 TA_assert(AO_fetch_and_sub1_write(&x) == 14);
1494 # else
1495 MISSING(AO_fetch_and_sub1);
1496 --x;
1497 # endif
1498 # if defined(AO_HAVE_short_store_write)
1499 AO_short_store_write(&s, 13);
1500 # else
1501 # if !defined(AO_HAVE_short_store) || !defined(AO_HAVE_short_store_full) \
1502 || !defined(AO_HAVE_short_store_release) \
1503 || !defined(AO_HAVE_short_store_release_write) \
1504 || !defined(AO_HAVE_short_store_write)
1505 MISSING(AO_short_store);
1506 # endif
1507 s = 13;
1508 # endif
1509 # if defined(AO_HAVE_short_load_write)
1510 TA_assert(AO_short_load(&s) == 13);
1511 # elif !defined(AO_HAVE_short_load) || !defined(AO_HAVE_short_load_acquire) \
1512 || !defined(AO_HAVE_short_load_acquire_read) \
1513 || !defined(AO_HAVE_short_load_dd_acquire_read) \
1514 || !defined(AO_HAVE_short_load_full) \
1515 || !defined(AO_HAVE_short_load_read)
1516 MISSING(AO_short_load);
1517 # endif
1518 # if defined(AO_HAVE_short_fetch_and_add_write)
1519 TA_assert(AO_short_fetch_and_add_write(&s, 42) == 13);
1520 TA_assert(AO_short_fetch_and_add_write(&s, (unsigned short)-42) == 55);
1521 # else
1522 MISSING(AO_short_fetch_and_add);
1523 # endif
1524 # if defined(AO_HAVE_short_fetch_and_add1_write)
1525 TA_assert(AO_short_fetch_and_add1_write(&s) == 13);
1526 # else
1527 MISSING(AO_short_fetch_and_add1);
1528 ++s;
1529 # endif
1530 # if defined(AO_HAVE_short_fetch_and_sub1_write)
1531 TA_assert(AO_short_fetch_and_sub1_write(&s) == 14);
1532 # else
1533 MISSING(AO_short_fetch_and_sub1);
1534 --s;
1535 # endif
1536 # if defined(AO_HAVE_char_store_write)
1537 AO_char_store_write(&b, 13);
1538 # else
1539 # if !defined(AO_HAVE_char_store) || !defined(AO_HAVE_char_store_full) \
1540 || !defined(AO_HAVE_char_store_release) \
1541 || !defined(AO_HAVE_char_store_release_write) \
1542 || !defined(AO_HAVE_char_store_write)
1543 MISSING(AO_char_store);
1544 # endif
1545 b = 13;
1546 # endif
1547 # if defined(AO_HAVE_char_load_write)
1548 TA_assert(AO_char_load(&b) == 13);
1549 # elif !defined(AO_HAVE_char_load) || !defined(AO_HAVE_char_load_acquire) \
1550 || !defined(AO_HAVE_char_load_acquire_read) \
1551 || !defined(AO_HAVE_char_load_dd_acquire_read) \
1552 || !defined(AO_HAVE_char_load_full) || !defined(AO_HAVE_char_load_read)
1553 MISSING(AO_char_load);
1554 # endif
1555 # if defined(AO_HAVE_char_fetch_and_add_write)
1556 TA_assert(AO_char_fetch_and_add_write(&b, 42) == 13);
1557 TA_assert(AO_char_fetch_and_add_write(&b, (unsigned char)-42) == 55);
1558 # else
1559 MISSING(AO_char_fetch_and_add);
1560 # endif
1561 # if defined(AO_HAVE_char_fetch_and_add1_write)
1562 TA_assert(AO_char_fetch_and_add1_write(&b) == 13);
1563 # else
1564 MISSING(AO_char_fetch_and_add1);
1565 ++b;
1566 # endif
1567 # if defined(AO_HAVE_char_fetch_and_sub1_write)
1568 TA_assert(AO_char_fetch_and_sub1_write(&b) == 14);
1569 # else
1570 MISSING(AO_char_fetch_and_sub1);
1571 --b;
1572 # endif
1573 # if defined(AO_HAVE_int_store_write)
1574 AO_int_store_write(&zz, 13);
1575 # else
1576 # if !defined(AO_HAVE_int_store) || !defined(AO_HAVE_int_store_full) \
1577 || !defined(AO_HAVE_int_store_release) \
1578 || !defined(AO_HAVE_int_store_release_write) \
1579 || !defined(AO_HAVE_int_store_write)
1580 MISSING(AO_int_store);
1581 # endif
1582 zz = 13;
1583 # endif
1584 # if defined(AO_HAVE_int_load_write)
1585 TA_assert(AO_int_load(&zz) == 13);
1586 # elif !defined(AO_HAVE_int_load) || !defined(AO_HAVE_int_load_acquire) \
1587 || !defined(AO_HAVE_int_load_acquire_read) \
1588 || !defined(AO_HAVE_int_load_dd_acquire_read) \
1589 || !defined(AO_HAVE_int_load_full) || !defined(AO_HAVE_int_load_read)
1590 MISSING(AO_int_load);
1591 # endif
1592 # if defined(AO_HAVE_int_fetch_and_add_write)
1593 TA_assert(AO_int_fetch_and_add_write(&zz, 42) == 13);
1594 TA_assert(AO_int_fetch_and_add_write(&zz, (unsigned int)-42) == 55);
1595 # else
1596 MISSING(AO_int_fetch_and_add);
1597 # endif
1598 # if defined(AO_HAVE_int_fetch_and_add1_write)
1599 TA_assert(AO_int_fetch_and_add1_write(&zz) == 13);
1600 # else
1601 MISSING(AO_int_fetch_and_add1);
1602 ++zz;
1603 # endif
1604 # if defined(AO_HAVE_int_fetch_and_sub1_write)
1605 TA_assert(AO_int_fetch_and_sub1_write(&zz) == 14);
1606 # else
1607 MISSING(AO_int_fetch_and_sub1);
1608 --zz;
1609 # endif
1610 # if defined(AO_HAVE_compare_and_swap_write)
1611 TA_assert(!AO_compare_and_swap_write(&x, 14, 42));
1612 TA_assert(x == 13);
1613 TA_assert(AO_compare_and_swap_write(&x, 13, 42));
1614 TA_assert(x == 42);
1615 # else
1616 MISSING(AO_compare_and_swap);
1617 if (x == 13) x = 42;
1618 # endif
1619 # if defined(AO_HAVE_or_write)
1620 AO_or_write(&x, 66);
1621 TA_assert(x == 106);
1622 # else
1623 MISSING(AO_or);
1624 x |= 66;
1625 # endif
1626 # if defined(AO_HAVE_xor_write)
1627 AO_xor_write(&x, 181);
1628 TA_assert(x == 223);
1629 # else
1630 MISSING(AO_xor);
1631 x ^= 181;
1632 # endif
1633 # if defined(AO_HAVE_and_write)
1634 AO_and_write(&x, 57);
1635 TA_assert(x == 25);
1636 # else
1637 MISSING(AO_and);
1638 x &= 57;
1639 # endif
1640 # if defined(AO_HAVE_fetch_compare_and_swap_write)
1641 TA_assert(AO_fetch_compare_and_swap_write(&x, 14, 117) == 25);
1642 TA_assert(x == 25);
1643 TA_assert(AO_fetch_compare_and_swap_write(&x, 25, 117) == 25);
1644 TA_assert(x == 117);
1645 # else
1646 MISSING(AO_fetch_compare_and_swap);
1647 if (x == 25) x = 117;
1648 # endif
1649 # if defined(AO_HAVE_double_load_write)
1650 old_w.AO_val1 = 3316;
1651 old_w.AO_val2 = 2921;
1652 new_w = AO_double_load_write(&old_w);
1653 TA_assert(new_w.AO_val1 == 3316 && new_w.AO_val2 == 2921);
1654 # elif !defined(AO_HAVE_double_load) \
1655 || !defined(AO_HAVE_double_load_acquire) \
1656 || !defined(AO_HAVE_double_load_acquire_read) \
1657 || !defined(AO_HAVE_double_load_dd_acquire_read) \
1658 || !defined(AO_HAVE_double_load_full) \
1659 || !defined(AO_HAVE_double_load_read)
1660 MISSING(AO_double_load);
1661 # endif
1662 # if defined(AO_HAVE_double_store_write)
1663 new_w.AO_val1 = 1375;
1664 new_w.AO_val2 = 8243;
1665 AO_double_store_write(&old_w, new_w);
1666 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
1667 AO_double_store_write(&old_w, new_w);
1668 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
1669 new_w.AO_val1 ^= old_w.AO_val1;
1670 new_w.AO_val2 ^= old_w.AO_val2;
1671 AO_double_store_write(&old_w, new_w);
1672 TA_assert(old_w.AO_val1 == 0 && old_w.AO_val2 == 0);
1673 # elif !defined(AO_HAVE_double_store) \
1674 || !defined(AO_HAVE_double_store_full) \
1675 || !defined(AO_HAVE_double_store_release) \
1676 || !defined(AO_HAVE_double_store_release_write) \
1677 || !defined(AO_HAVE_double_store_write)
1678 MISSING(AO_double_store);
1679 # endif
1680 # if defined(AO_HAVE_compare_double_and_swap_double_write)
1681 TA_assert(!AO_compare_double_and_swap_double_write(&w, 17, 42, 12, 13));
1682 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1683 TA_assert(AO_compare_double_and_swap_double_write(&w, 0, 0, 12, 13));
1684 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1685 TA_assert(!AO_compare_double_and_swap_double_write(&w, 12, 14, 64, 33));
1686 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1687 TA_assert(!AO_compare_double_and_swap_double_write(&w, 11, 13, 85, 82));
1688 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1689 TA_assert(!AO_compare_double_and_swap_double_write(&w, 13, 12, 17, 42));
1690 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1691 TA_assert(AO_compare_double_and_swap_double_write(&w, 12, 13, 17, 42));
1692 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1693 TA_assert(AO_compare_double_and_swap_double_write(&w, 17, 42, 0, 0));
1694 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1695 # else
1696 MISSING(AO_compare_double_and_swap_double);
1697 # endif
1698 # if defined(AO_HAVE_compare_and_swap_double_write)
1699 TA_assert(!AO_compare_and_swap_double_write(&w, 17, 12, 13));
1700 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1701 TA_assert(AO_compare_and_swap_double_write(&w, 0, 12, 13));
1702 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1703 TA_assert(!AO_compare_and_swap_double_write(&w, 13, 12, 33));
1704 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1705 TA_assert(!AO_compare_and_swap_double_write(&w, 1213, 48, 86));
1706 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1707 TA_assert(AO_compare_and_swap_double_write(&w, 12, 17, 42));
1708 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1709 TA_assert(AO_compare_and_swap_double_write(&w, 17, 0, 0));
1710 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1711 # else
1712 MISSING(AO_compare_and_swap_double);
1713 # endif
1714 # if defined(AO_HAVE_double_compare_and_swap_write)
1715 old_w.AO_val1 = 4116;
1716 old_w.AO_val2 = 2121;
1717 new_w.AO_val1 = 8537;
1718 new_w.AO_val2 = 6410;
1719 TA_assert(!AO_double_compare_and_swap_write(&w, old_w, new_w));
1720 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1721 TA_assert(AO_double_compare_and_swap_write(&w, w, new_w));
1722 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1723 old_w.AO_val1 = new_w.AO_val1;
1724 old_w.AO_val2 = 29;
1725 new_w.AO_val1 = 820;
1726 new_w.AO_val2 = 5917;
1727 TA_assert(!AO_double_compare_and_swap_write(&w, old_w, new_w));
1728 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1729 old_w.AO_val1 = 11;
1730 old_w.AO_val2 = 6410;
1731 new_w.AO_val1 = 3552;
1732 new_w.AO_val2 = 1746;
1733 TA_assert(!AO_double_compare_and_swap_write(&w, old_w, new_w));
1734 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1735 old_w.AO_val1 = old_w.AO_val2;
1736 old_w.AO_val2 = 8537;
1737 new_w.AO_val1 = 4116;
1738 new_w.AO_val2 = 2121;
1739 TA_assert(!AO_double_compare_and_swap_write(&w, old_w, new_w));
1740 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
1741 old_w.AO_val1 = old_w.AO_val2;
1742 old_w.AO_val2 = 6410;
1743 new_w.AO_val1 = 1;
1744 TA_assert(AO_double_compare_and_swap_write(&w, old_w, new_w));
1745 TA_assert(w.AO_val1 == 1 && w.AO_val2 == 2121);
1746 old_w.AO_val1 = new_w.AO_val1;
1747 old_w.AO_val2 = w.AO_val2;
1748 new_w.AO_val1--;
1749 new_w.AO_val2 = 0;
1750 TA_assert(AO_double_compare_and_swap_write(&w, old_w, new_w));
1751 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1752 # else
1753 MISSING(AO_double_compare_and_swap);
1754 # endif
1755 }
1756 /*
1757 * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved.
1758 *
1759 * This file is covered by the GNU general public license, version 2.
1760 * see COPYING for details.
1761 */
1762
1763 /* Some basic sanity tests. These do not test the barrier semantics. */
1764
1765 #undef TA_assert
1766 #define TA_assert(e) \
1767 if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _full)\n", \
1768 __FILE__, __LINE__), exit(1); }
1769
1770 #undef MISSING
1771 #define MISSING(name) \
1772 printf("Missing: %s\n", #name "_full")
1773
test_atomic_full(void)1774 void test_atomic_full(void)
1775 {
1776 AO_t x;
1777 unsigned char b;
1778 unsigned short s;
1779 unsigned int zz;
1780 # if defined(AO_HAVE_test_and_set_full)
1781 AO_TS_t z = AO_TS_INITIALIZER;
1782 # endif
1783 # if defined(AO_HAVE_double_compare_and_swap_full) \
1784 || defined(AO_HAVE_double_load_full) \
1785 || defined(AO_HAVE_double_store_full)
1786 AO_double_t old_w;
1787 AO_double_t new_w;
1788 # endif
1789 # if defined(AO_HAVE_compare_and_swap_double_full) \
1790 || defined(AO_HAVE_compare_double_and_swap_double_full) \
1791 || defined(AO_HAVE_double_compare_and_swap_full)
1792 AO_double_t w;
1793 w.AO_val1 = 0;
1794 w.AO_val2 = 0;
1795 # endif
1796
1797 # if defined(AO_HAVE_nop_full)
1798 AO_nop_full();
1799 # elif !defined(AO_HAVE_nop) || !defined(AO_HAVE_nop_full) \
1800 || !defined(AO_HAVE_nop_read) || !defined(AO_HAVE_nop_write)
1801 MISSING(AO_nop);
1802 # endif
1803 # if defined(AO_HAVE_store_full)
1804 AO_store_full(&x, 13);
1805 TA_assert (x == 13);
1806 # else
1807 # if !defined(AO_HAVE_store) || !defined(AO_HAVE_store_full) \
1808 || !defined(AO_HAVE_store_release) \
1809 || !defined(AO_HAVE_store_release_write) \
1810 || !defined(AO_HAVE_store_write)
1811 MISSING(AO_store);
1812 # endif
1813 x = 13;
1814 # endif
1815 # if defined(AO_HAVE_load_full)
1816 TA_assert(AO_load_full(&x) == 13);
1817 # elif !defined(AO_HAVE_load) || !defined(AO_HAVE_load_acquire) \
1818 || !defined(AO_HAVE_load_acquire_read) \
1819 || !defined(AO_HAVE_load_dd_acquire_read) \
1820 || !defined(AO_HAVE_load_full) || !defined(AO_HAVE_load_read)
1821 MISSING(AO_load);
1822 # endif
1823 # if defined(AO_HAVE_test_and_set_full)
1824 assert(AO_test_and_set_full(&z) == AO_TS_CLEAR);
1825 assert(AO_test_and_set_full(&z) == AO_TS_SET);
1826 assert(AO_test_and_set_full(&z) == AO_TS_SET);
1827 AO_CLEAR(&z);
1828 # else
1829 MISSING(AO_test_and_set);
1830 # endif
1831 # if defined(AO_HAVE_fetch_and_add_full)
1832 TA_assert(AO_fetch_and_add_full(&x, 42) == 13);
1833 TA_assert(AO_fetch_and_add_full(&x, (AO_t)(-42)) == 55);
1834 # else
1835 MISSING(AO_fetch_and_add);
1836 # endif
1837 # if defined(AO_HAVE_fetch_and_add1_full)
1838 TA_assert(AO_fetch_and_add1_full(&x) == 13);
1839 # else
1840 MISSING(AO_fetch_and_add1);
1841 ++x;
1842 # endif
1843 # if defined(AO_HAVE_fetch_and_sub1_full)
1844 TA_assert(AO_fetch_and_sub1_full(&x) == 14);
1845 # else
1846 MISSING(AO_fetch_and_sub1);
1847 --x;
1848 # endif
1849 # if defined(AO_HAVE_short_store_full)
1850 AO_short_store_full(&s, 13);
1851 # else
1852 # if !defined(AO_HAVE_short_store) || !defined(AO_HAVE_short_store_full) \
1853 || !defined(AO_HAVE_short_store_release) \
1854 || !defined(AO_HAVE_short_store_release_write) \
1855 || !defined(AO_HAVE_short_store_write)
1856 MISSING(AO_short_store);
1857 # endif
1858 s = 13;
1859 # endif
1860 # if defined(AO_HAVE_short_load_full)
1861 TA_assert(AO_short_load(&s) == 13);
1862 # elif !defined(AO_HAVE_short_load) || !defined(AO_HAVE_short_load_acquire) \
1863 || !defined(AO_HAVE_short_load_acquire_read) \
1864 || !defined(AO_HAVE_short_load_dd_acquire_read) \
1865 || !defined(AO_HAVE_short_load_full) \
1866 || !defined(AO_HAVE_short_load_read)
1867 MISSING(AO_short_load);
1868 # endif
1869 # if defined(AO_HAVE_short_fetch_and_add_full)
1870 TA_assert(AO_short_fetch_and_add_full(&s, 42) == 13);
1871 TA_assert(AO_short_fetch_and_add_full(&s, (unsigned short)-42) == 55);
1872 # else
1873 MISSING(AO_short_fetch_and_add);
1874 # endif
1875 # if defined(AO_HAVE_short_fetch_and_add1_full)
1876 TA_assert(AO_short_fetch_and_add1_full(&s) == 13);
1877 # else
1878 MISSING(AO_short_fetch_and_add1);
1879 ++s;
1880 # endif
1881 # if defined(AO_HAVE_short_fetch_and_sub1_full)
1882 TA_assert(AO_short_fetch_and_sub1_full(&s) == 14);
1883 # else
1884 MISSING(AO_short_fetch_and_sub1);
1885 --s;
1886 # endif
1887 # if defined(AO_HAVE_char_store_full)
1888 AO_char_store_full(&b, 13);
1889 # else
1890 # if !defined(AO_HAVE_char_store) || !defined(AO_HAVE_char_store_full) \
1891 || !defined(AO_HAVE_char_store_release) \
1892 || !defined(AO_HAVE_char_store_release_write) \
1893 || !defined(AO_HAVE_char_store_write)
1894 MISSING(AO_char_store);
1895 # endif
1896 b = 13;
1897 # endif
1898 # if defined(AO_HAVE_char_load_full)
1899 TA_assert(AO_char_load(&b) == 13);
1900 # elif !defined(AO_HAVE_char_load) || !defined(AO_HAVE_char_load_acquire) \
1901 || !defined(AO_HAVE_char_load_acquire_read) \
1902 || !defined(AO_HAVE_char_load_dd_acquire_read) \
1903 || !defined(AO_HAVE_char_load_full) || !defined(AO_HAVE_char_load_read)
1904 MISSING(AO_char_load);
1905 # endif
1906 # if defined(AO_HAVE_char_fetch_and_add_full)
1907 TA_assert(AO_char_fetch_and_add_full(&b, 42) == 13);
1908 TA_assert(AO_char_fetch_and_add_full(&b, (unsigned char)-42) == 55);
1909 # else
1910 MISSING(AO_char_fetch_and_add);
1911 # endif
1912 # if defined(AO_HAVE_char_fetch_and_add1_full)
1913 TA_assert(AO_char_fetch_and_add1_full(&b) == 13);
1914 # else
1915 MISSING(AO_char_fetch_and_add1);
1916 ++b;
1917 # endif
1918 # if defined(AO_HAVE_char_fetch_and_sub1_full)
1919 TA_assert(AO_char_fetch_and_sub1_full(&b) == 14);
1920 # else
1921 MISSING(AO_char_fetch_and_sub1);
1922 --b;
1923 # endif
1924 # if defined(AO_HAVE_int_store_full)
1925 AO_int_store_full(&zz, 13);
1926 # else
1927 # if !defined(AO_HAVE_int_store) || !defined(AO_HAVE_int_store_full) \
1928 || !defined(AO_HAVE_int_store_release) \
1929 || !defined(AO_HAVE_int_store_release_write) \
1930 || !defined(AO_HAVE_int_store_write)
1931 MISSING(AO_int_store);
1932 # endif
1933 zz = 13;
1934 # endif
1935 # if defined(AO_HAVE_int_load_full)
1936 TA_assert(AO_int_load(&zz) == 13);
1937 # elif !defined(AO_HAVE_int_load) || !defined(AO_HAVE_int_load_acquire) \
1938 || !defined(AO_HAVE_int_load_acquire_read) \
1939 || !defined(AO_HAVE_int_load_dd_acquire_read) \
1940 || !defined(AO_HAVE_int_load_full) || !defined(AO_HAVE_int_load_read)
1941 MISSING(AO_int_load);
1942 # endif
1943 # if defined(AO_HAVE_int_fetch_and_add_full)
1944 TA_assert(AO_int_fetch_and_add_full(&zz, 42) == 13);
1945 TA_assert(AO_int_fetch_and_add_full(&zz, (unsigned int)-42) == 55);
1946 # else
1947 MISSING(AO_int_fetch_and_add);
1948 # endif
1949 # if defined(AO_HAVE_int_fetch_and_add1_full)
1950 TA_assert(AO_int_fetch_and_add1_full(&zz) == 13);
1951 # else
1952 MISSING(AO_int_fetch_and_add1);
1953 ++zz;
1954 # endif
1955 # if defined(AO_HAVE_int_fetch_and_sub1_full)
1956 TA_assert(AO_int_fetch_and_sub1_full(&zz) == 14);
1957 # else
1958 MISSING(AO_int_fetch_and_sub1);
1959 --zz;
1960 # endif
1961 # if defined(AO_HAVE_compare_and_swap_full)
1962 TA_assert(!AO_compare_and_swap_full(&x, 14, 42));
1963 TA_assert(x == 13);
1964 TA_assert(AO_compare_and_swap_full(&x, 13, 42));
1965 TA_assert(x == 42);
1966 # else
1967 MISSING(AO_compare_and_swap);
1968 if (x == 13) x = 42;
1969 # endif
1970 # if defined(AO_HAVE_or_full)
1971 AO_or_full(&x, 66);
1972 TA_assert(x == 106);
1973 # else
1974 MISSING(AO_or);
1975 x |= 66;
1976 # endif
1977 # if defined(AO_HAVE_xor_full)
1978 AO_xor_full(&x, 181);
1979 TA_assert(x == 223);
1980 # else
1981 MISSING(AO_xor);
1982 x ^= 181;
1983 # endif
1984 # if defined(AO_HAVE_and_full)
1985 AO_and_full(&x, 57);
1986 TA_assert(x == 25);
1987 # else
1988 MISSING(AO_and);
1989 x &= 57;
1990 # endif
1991 # if defined(AO_HAVE_fetch_compare_and_swap_full)
1992 TA_assert(AO_fetch_compare_and_swap_full(&x, 14, 117) == 25);
1993 TA_assert(x == 25);
1994 TA_assert(AO_fetch_compare_and_swap_full(&x, 25, 117) == 25);
1995 TA_assert(x == 117);
1996 # else
1997 MISSING(AO_fetch_compare_and_swap);
1998 if (x == 25) x = 117;
1999 # endif
2000 # if defined(AO_HAVE_double_load_full)
2001 old_w.AO_val1 = 3316;
2002 old_w.AO_val2 = 2921;
2003 new_w = AO_double_load_full(&old_w);
2004 TA_assert(new_w.AO_val1 == 3316 && new_w.AO_val2 == 2921);
2005 # elif !defined(AO_HAVE_double_load) \
2006 || !defined(AO_HAVE_double_load_acquire) \
2007 || !defined(AO_HAVE_double_load_acquire_read) \
2008 || !defined(AO_HAVE_double_load_dd_acquire_read) \
2009 || !defined(AO_HAVE_double_load_full) \
2010 || !defined(AO_HAVE_double_load_read)
2011 MISSING(AO_double_load);
2012 # endif
2013 # if defined(AO_HAVE_double_store_full)
2014 new_w.AO_val1 = 1375;
2015 new_w.AO_val2 = 8243;
2016 AO_double_store_full(&old_w, new_w);
2017 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
2018 AO_double_store_full(&old_w, new_w);
2019 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
2020 new_w.AO_val1 ^= old_w.AO_val1;
2021 new_w.AO_val2 ^= old_w.AO_val2;
2022 AO_double_store_full(&old_w, new_w);
2023 TA_assert(old_w.AO_val1 == 0 && old_w.AO_val2 == 0);
2024 # elif !defined(AO_HAVE_double_store) \
2025 || !defined(AO_HAVE_double_store_full) \
2026 || !defined(AO_HAVE_double_store_release) \
2027 || !defined(AO_HAVE_double_store_release_write) \
2028 || !defined(AO_HAVE_double_store_write)
2029 MISSING(AO_double_store);
2030 # endif
2031 # if defined(AO_HAVE_compare_double_and_swap_double_full)
2032 TA_assert(!AO_compare_double_and_swap_double_full(&w, 17, 42, 12, 13));
2033 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2034 TA_assert(AO_compare_double_and_swap_double_full(&w, 0, 0, 12, 13));
2035 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2036 TA_assert(!AO_compare_double_and_swap_double_full(&w, 12, 14, 64, 33));
2037 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2038 TA_assert(!AO_compare_double_and_swap_double_full(&w, 11, 13, 85, 82));
2039 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2040 TA_assert(!AO_compare_double_and_swap_double_full(&w, 13, 12, 17, 42));
2041 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2042 TA_assert(AO_compare_double_and_swap_double_full(&w, 12, 13, 17, 42));
2043 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
2044 TA_assert(AO_compare_double_and_swap_double_full(&w, 17, 42, 0, 0));
2045 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2046 # else
2047 MISSING(AO_compare_double_and_swap_double);
2048 # endif
2049 # if defined(AO_HAVE_compare_and_swap_double_full)
2050 TA_assert(!AO_compare_and_swap_double_full(&w, 17, 12, 13));
2051 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2052 TA_assert(AO_compare_and_swap_double_full(&w, 0, 12, 13));
2053 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2054 TA_assert(!AO_compare_and_swap_double_full(&w, 13, 12, 33));
2055 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2056 TA_assert(!AO_compare_and_swap_double_full(&w, 1213, 48, 86));
2057 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2058 TA_assert(AO_compare_and_swap_double_full(&w, 12, 17, 42));
2059 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
2060 TA_assert(AO_compare_and_swap_double_full(&w, 17, 0, 0));
2061 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2062 # else
2063 MISSING(AO_compare_and_swap_double);
2064 # endif
2065 # if defined(AO_HAVE_double_compare_and_swap_full)
2066 old_w.AO_val1 = 4116;
2067 old_w.AO_val2 = 2121;
2068 new_w.AO_val1 = 8537;
2069 new_w.AO_val2 = 6410;
2070 TA_assert(!AO_double_compare_and_swap_full(&w, old_w, new_w));
2071 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2072 TA_assert(AO_double_compare_and_swap_full(&w, w, new_w));
2073 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2074 old_w.AO_val1 = new_w.AO_val1;
2075 old_w.AO_val2 = 29;
2076 new_w.AO_val1 = 820;
2077 new_w.AO_val2 = 5917;
2078 TA_assert(!AO_double_compare_and_swap_full(&w, old_w, new_w));
2079 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2080 old_w.AO_val1 = 11;
2081 old_w.AO_val2 = 6410;
2082 new_w.AO_val1 = 3552;
2083 new_w.AO_val2 = 1746;
2084 TA_assert(!AO_double_compare_and_swap_full(&w, old_w, new_w));
2085 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2086 old_w.AO_val1 = old_w.AO_val2;
2087 old_w.AO_val2 = 8537;
2088 new_w.AO_val1 = 4116;
2089 new_w.AO_val2 = 2121;
2090 TA_assert(!AO_double_compare_and_swap_full(&w, old_w, new_w));
2091 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2092 old_w.AO_val1 = old_w.AO_val2;
2093 old_w.AO_val2 = 6410;
2094 new_w.AO_val1 = 1;
2095 TA_assert(AO_double_compare_and_swap_full(&w, old_w, new_w));
2096 TA_assert(w.AO_val1 == 1 && w.AO_val2 == 2121);
2097 old_w.AO_val1 = new_w.AO_val1;
2098 old_w.AO_val2 = w.AO_val2;
2099 new_w.AO_val1--;
2100 new_w.AO_val2 = 0;
2101 TA_assert(AO_double_compare_and_swap_full(&w, old_w, new_w));
2102 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2103 # else
2104 MISSING(AO_double_compare_and_swap);
2105 # endif
2106 }
2107 /*
2108 * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved.
2109 *
2110 * This file is covered by the GNU general public license, version 2.
2111 * see COPYING for details.
2112 */
2113
2114 /* Some basic sanity tests. These do not test the barrier semantics. */
2115
2116 #undef TA_assert
2117 #define TA_assert(e) \
2118 if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _release_write)\n", \
2119 __FILE__, __LINE__), exit(1); }
2120
2121 #undef MISSING
2122 #define MISSING(name) \
2123 printf("Missing: %s\n", #name "_release_write")
2124
test_atomic_release_write(void)2125 void test_atomic_release_write(void)
2126 {
2127 AO_t x;
2128 unsigned char b;
2129 unsigned short s;
2130 unsigned int zz;
2131 # if defined(AO_HAVE_test_and_set_release_write)
2132 AO_TS_t z = AO_TS_INITIALIZER;
2133 # endif
2134 # if defined(AO_HAVE_double_compare_and_swap_release_write) \
2135 || defined(AO_HAVE_double_load_release_write) \
2136 || defined(AO_HAVE_double_store_release_write)
2137 AO_double_t old_w;
2138 AO_double_t new_w;
2139 # endif
2140 # if defined(AO_HAVE_compare_and_swap_double_release_write) \
2141 || defined(AO_HAVE_compare_double_and_swap_double_release_write) \
2142 || defined(AO_HAVE_double_compare_and_swap_release_write)
2143 AO_double_t w;
2144 w.AO_val1 = 0;
2145 w.AO_val2 = 0;
2146 # endif
2147
2148 # if defined(AO_HAVE_nop_release_write)
2149 AO_nop_release_write();
2150 # elif !defined(AO_HAVE_nop) || !defined(AO_HAVE_nop_full) \
2151 || !defined(AO_HAVE_nop_read) || !defined(AO_HAVE_nop_write)
2152 MISSING(AO_nop);
2153 # endif
2154 # if defined(AO_HAVE_store_release_write)
2155 AO_store_release_write(&x, 13);
2156 TA_assert (x == 13);
2157 # else
2158 # if !defined(AO_HAVE_store) || !defined(AO_HAVE_store_full) \
2159 || !defined(AO_HAVE_store_release) \
2160 || !defined(AO_HAVE_store_release_write) \
2161 || !defined(AO_HAVE_store_write)
2162 MISSING(AO_store);
2163 # endif
2164 x = 13;
2165 # endif
2166 # if defined(AO_HAVE_load_release_write)
2167 TA_assert(AO_load_release_write(&x) == 13);
2168 # elif !defined(AO_HAVE_load) || !defined(AO_HAVE_load_acquire) \
2169 || !defined(AO_HAVE_load_acquire_read) \
2170 || !defined(AO_HAVE_load_dd_acquire_read) \
2171 || !defined(AO_HAVE_load_full) || !defined(AO_HAVE_load_read)
2172 MISSING(AO_load);
2173 # endif
2174 # if defined(AO_HAVE_test_and_set_release_write)
2175 assert(AO_test_and_set_release_write(&z) == AO_TS_CLEAR);
2176 assert(AO_test_and_set_release_write(&z) == AO_TS_SET);
2177 assert(AO_test_and_set_release_write(&z) == AO_TS_SET);
2178 AO_CLEAR(&z);
2179 # else
2180 MISSING(AO_test_and_set);
2181 # endif
2182 # if defined(AO_HAVE_fetch_and_add_release_write)
2183 TA_assert(AO_fetch_and_add_release_write(&x, 42) == 13);
2184 TA_assert(AO_fetch_and_add_release_write(&x, (AO_t)(-42)) == 55);
2185 # else
2186 MISSING(AO_fetch_and_add);
2187 # endif
2188 # if defined(AO_HAVE_fetch_and_add1_release_write)
2189 TA_assert(AO_fetch_and_add1_release_write(&x) == 13);
2190 # else
2191 MISSING(AO_fetch_and_add1);
2192 ++x;
2193 # endif
2194 # if defined(AO_HAVE_fetch_and_sub1_release_write)
2195 TA_assert(AO_fetch_and_sub1_release_write(&x) == 14);
2196 # else
2197 MISSING(AO_fetch_and_sub1);
2198 --x;
2199 # endif
2200 # if defined(AO_HAVE_short_store_release_write)
2201 AO_short_store_release_write(&s, 13);
2202 # else
2203 # if !defined(AO_HAVE_short_store) || !defined(AO_HAVE_short_store_full) \
2204 || !defined(AO_HAVE_short_store_release) \
2205 || !defined(AO_HAVE_short_store_release_write) \
2206 || !defined(AO_HAVE_short_store_write)
2207 MISSING(AO_short_store);
2208 # endif
2209 s = 13;
2210 # endif
2211 # if defined(AO_HAVE_short_load_release_write)
2212 TA_assert(AO_short_load(&s) == 13);
2213 # elif !defined(AO_HAVE_short_load) || !defined(AO_HAVE_short_load_acquire) \
2214 || !defined(AO_HAVE_short_load_acquire_read) \
2215 || !defined(AO_HAVE_short_load_dd_acquire_read) \
2216 || !defined(AO_HAVE_short_load_full) \
2217 || !defined(AO_HAVE_short_load_read)
2218 MISSING(AO_short_load);
2219 # endif
2220 # if defined(AO_HAVE_short_fetch_and_add_release_write)
2221 TA_assert(AO_short_fetch_and_add_release_write(&s, 42) == 13);
2222 TA_assert(AO_short_fetch_and_add_release_write(&s, (unsigned short)-42) == 55);
2223 # else
2224 MISSING(AO_short_fetch_and_add);
2225 # endif
2226 # if defined(AO_HAVE_short_fetch_and_add1_release_write)
2227 TA_assert(AO_short_fetch_and_add1_release_write(&s) == 13);
2228 # else
2229 MISSING(AO_short_fetch_and_add1);
2230 ++s;
2231 # endif
2232 # if defined(AO_HAVE_short_fetch_and_sub1_release_write)
2233 TA_assert(AO_short_fetch_and_sub1_release_write(&s) == 14);
2234 # else
2235 MISSING(AO_short_fetch_and_sub1);
2236 --s;
2237 # endif
2238 # if defined(AO_HAVE_char_store_release_write)
2239 AO_char_store_release_write(&b, 13);
2240 # else
2241 # if !defined(AO_HAVE_char_store) || !defined(AO_HAVE_char_store_full) \
2242 || !defined(AO_HAVE_char_store_release) \
2243 || !defined(AO_HAVE_char_store_release_write) \
2244 || !defined(AO_HAVE_char_store_write)
2245 MISSING(AO_char_store);
2246 # endif
2247 b = 13;
2248 # endif
2249 # if defined(AO_HAVE_char_load_release_write)
2250 TA_assert(AO_char_load(&b) == 13);
2251 # elif !defined(AO_HAVE_char_load) || !defined(AO_HAVE_char_load_acquire) \
2252 || !defined(AO_HAVE_char_load_acquire_read) \
2253 || !defined(AO_HAVE_char_load_dd_acquire_read) \
2254 || !defined(AO_HAVE_char_load_full) || !defined(AO_HAVE_char_load_read)
2255 MISSING(AO_char_load);
2256 # endif
2257 # if defined(AO_HAVE_char_fetch_and_add_release_write)
2258 TA_assert(AO_char_fetch_and_add_release_write(&b, 42) == 13);
2259 TA_assert(AO_char_fetch_and_add_release_write(&b, (unsigned char)-42) == 55);
2260 # else
2261 MISSING(AO_char_fetch_and_add);
2262 # endif
2263 # if defined(AO_HAVE_char_fetch_and_add1_release_write)
2264 TA_assert(AO_char_fetch_and_add1_release_write(&b) == 13);
2265 # else
2266 MISSING(AO_char_fetch_and_add1);
2267 ++b;
2268 # endif
2269 # if defined(AO_HAVE_char_fetch_and_sub1_release_write)
2270 TA_assert(AO_char_fetch_and_sub1_release_write(&b) == 14);
2271 # else
2272 MISSING(AO_char_fetch_and_sub1);
2273 --b;
2274 # endif
2275 # if defined(AO_HAVE_int_store_release_write)
2276 AO_int_store_release_write(&zz, 13);
2277 # else
2278 # if !defined(AO_HAVE_int_store) || !defined(AO_HAVE_int_store_full) \
2279 || !defined(AO_HAVE_int_store_release) \
2280 || !defined(AO_HAVE_int_store_release_write) \
2281 || !defined(AO_HAVE_int_store_write)
2282 MISSING(AO_int_store);
2283 # endif
2284 zz = 13;
2285 # endif
2286 # if defined(AO_HAVE_int_load_release_write)
2287 TA_assert(AO_int_load(&zz) == 13);
2288 # elif !defined(AO_HAVE_int_load) || !defined(AO_HAVE_int_load_acquire) \
2289 || !defined(AO_HAVE_int_load_acquire_read) \
2290 || !defined(AO_HAVE_int_load_dd_acquire_read) \
2291 || !defined(AO_HAVE_int_load_full) || !defined(AO_HAVE_int_load_read)
2292 MISSING(AO_int_load);
2293 # endif
2294 # if defined(AO_HAVE_int_fetch_and_add_release_write)
2295 TA_assert(AO_int_fetch_and_add_release_write(&zz, 42) == 13);
2296 TA_assert(AO_int_fetch_and_add_release_write(&zz, (unsigned int)-42) == 55);
2297 # else
2298 MISSING(AO_int_fetch_and_add);
2299 # endif
2300 # if defined(AO_HAVE_int_fetch_and_add1_release_write)
2301 TA_assert(AO_int_fetch_and_add1_release_write(&zz) == 13);
2302 # else
2303 MISSING(AO_int_fetch_and_add1);
2304 ++zz;
2305 # endif
2306 # if defined(AO_HAVE_int_fetch_and_sub1_release_write)
2307 TA_assert(AO_int_fetch_and_sub1_release_write(&zz) == 14);
2308 # else
2309 MISSING(AO_int_fetch_and_sub1);
2310 --zz;
2311 # endif
2312 # if defined(AO_HAVE_compare_and_swap_release_write)
2313 TA_assert(!AO_compare_and_swap_release_write(&x, 14, 42));
2314 TA_assert(x == 13);
2315 TA_assert(AO_compare_and_swap_release_write(&x, 13, 42));
2316 TA_assert(x == 42);
2317 # else
2318 MISSING(AO_compare_and_swap);
2319 if (x == 13) x = 42;
2320 # endif
2321 # if defined(AO_HAVE_or_release_write)
2322 AO_or_release_write(&x, 66);
2323 TA_assert(x == 106);
2324 # else
2325 MISSING(AO_or);
2326 x |= 66;
2327 # endif
2328 # if defined(AO_HAVE_xor_release_write)
2329 AO_xor_release_write(&x, 181);
2330 TA_assert(x == 223);
2331 # else
2332 MISSING(AO_xor);
2333 x ^= 181;
2334 # endif
2335 # if defined(AO_HAVE_and_release_write)
2336 AO_and_release_write(&x, 57);
2337 TA_assert(x == 25);
2338 # else
2339 MISSING(AO_and);
2340 x &= 57;
2341 # endif
2342 # if defined(AO_HAVE_fetch_compare_and_swap_release_write)
2343 TA_assert(AO_fetch_compare_and_swap_release_write(&x, 14, 117) == 25);
2344 TA_assert(x == 25);
2345 TA_assert(AO_fetch_compare_and_swap_release_write(&x, 25, 117) == 25);
2346 TA_assert(x == 117);
2347 # else
2348 MISSING(AO_fetch_compare_and_swap);
2349 if (x == 25) x = 117;
2350 # endif
2351 # if defined(AO_HAVE_double_load_release_write)
2352 old_w.AO_val1 = 3316;
2353 old_w.AO_val2 = 2921;
2354 new_w = AO_double_load_release_write(&old_w);
2355 TA_assert(new_w.AO_val1 == 3316 && new_w.AO_val2 == 2921);
2356 # elif !defined(AO_HAVE_double_load) \
2357 || !defined(AO_HAVE_double_load_acquire) \
2358 || !defined(AO_HAVE_double_load_acquire_read) \
2359 || !defined(AO_HAVE_double_load_dd_acquire_read) \
2360 || !defined(AO_HAVE_double_load_full) \
2361 || !defined(AO_HAVE_double_load_read)
2362 MISSING(AO_double_load);
2363 # endif
2364 # if defined(AO_HAVE_double_store_release_write)
2365 new_w.AO_val1 = 1375;
2366 new_w.AO_val2 = 8243;
2367 AO_double_store_release_write(&old_w, new_w);
2368 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
2369 AO_double_store_release_write(&old_w, new_w);
2370 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
2371 new_w.AO_val1 ^= old_w.AO_val1;
2372 new_w.AO_val2 ^= old_w.AO_val2;
2373 AO_double_store_release_write(&old_w, new_w);
2374 TA_assert(old_w.AO_val1 == 0 && old_w.AO_val2 == 0);
2375 # elif !defined(AO_HAVE_double_store) \
2376 || !defined(AO_HAVE_double_store_full) \
2377 || !defined(AO_HAVE_double_store_release) \
2378 || !defined(AO_HAVE_double_store_release_write) \
2379 || !defined(AO_HAVE_double_store_write)
2380 MISSING(AO_double_store);
2381 # endif
2382 # if defined(AO_HAVE_compare_double_and_swap_double_release_write)
2383 TA_assert(!AO_compare_double_and_swap_double_release_write(&w, 17, 42, 12, 13));
2384 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2385 TA_assert(AO_compare_double_and_swap_double_release_write(&w, 0, 0, 12, 13));
2386 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2387 TA_assert(!AO_compare_double_and_swap_double_release_write(&w, 12, 14, 64, 33));
2388 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2389 TA_assert(!AO_compare_double_and_swap_double_release_write(&w, 11, 13, 85, 82));
2390 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2391 TA_assert(!AO_compare_double_and_swap_double_release_write(&w, 13, 12, 17, 42));
2392 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2393 TA_assert(AO_compare_double_and_swap_double_release_write(&w, 12, 13, 17, 42));
2394 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
2395 TA_assert(AO_compare_double_and_swap_double_release_write(&w, 17, 42, 0, 0));
2396 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2397 # else
2398 MISSING(AO_compare_double_and_swap_double);
2399 # endif
2400 # if defined(AO_HAVE_compare_and_swap_double_release_write)
2401 TA_assert(!AO_compare_and_swap_double_release_write(&w, 17, 12, 13));
2402 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2403 TA_assert(AO_compare_and_swap_double_release_write(&w, 0, 12, 13));
2404 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2405 TA_assert(!AO_compare_and_swap_double_release_write(&w, 13, 12, 33));
2406 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2407 TA_assert(!AO_compare_and_swap_double_release_write(&w, 1213, 48, 86));
2408 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2409 TA_assert(AO_compare_and_swap_double_release_write(&w, 12, 17, 42));
2410 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
2411 TA_assert(AO_compare_and_swap_double_release_write(&w, 17, 0, 0));
2412 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2413 # else
2414 MISSING(AO_compare_and_swap_double);
2415 # endif
2416 # if defined(AO_HAVE_double_compare_and_swap_release_write)
2417 old_w.AO_val1 = 4116;
2418 old_w.AO_val2 = 2121;
2419 new_w.AO_val1 = 8537;
2420 new_w.AO_val2 = 6410;
2421 TA_assert(!AO_double_compare_and_swap_release_write(&w, old_w, new_w));
2422 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2423 TA_assert(AO_double_compare_and_swap_release_write(&w, w, new_w));
2424 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2425 old_w.AO_val1 = new_w.AO_val1;
2426 old_w.AO_val2 = 29;
2427 new_w.AO_val1 = 820;
2428 new_w.AO_val2 = 5917;
2429 TA_assert(!AO_double_compare_and_swap_release_write(&w, old_w, new_w));
2430 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2431 old_w.AO_val1 = 11;
2432 old_w.AO_val2 = 6410;
2433 new_w.AO_val1 = 3552;
2434 new_w.AO_val2 = 1746;
2435 TA_assert(!AO_double_compare_and_swap_release_write(&w, old_w, new_w));
2436 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2437 old_w.AO_val1 = old_w.AO_val2;
2438 old_w.AO_val2 = 8537;
2439 new_w.AO_val1 = 4116;
2440 new_w.AO_val2 = 2121;
2441 TA_assert(!AO_double_compare_and_swap_release_write(&w, old_w, new_w));
2442 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2443 old_w.AO_val1 = old_w.AO_val2;
2444 old_w.AO_val2 = 6410;
2445 new_w.AO_val1 = 1;
2446 TA_assert(AO_double_compare_and_swap_release_write(&w, old_w, new_w));
2447 TA_assert(w.AO_val1 == 1 && w.AO_val2 == 2121);
2448 old_w.AO_val1 = new_w.AO_val1;
2449 old_w.AO_val2 = w.AO_val2;
2450 new_w.AO_val1--;
2451 new_w.AO_val2 = 0;
2452 TA_assert(AO_double_compare_and_swap_release_write(&w, old_w, new_w));
2453 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2454 # else
2455 MISSING(AO_double_compare_and_swap);
2456 # endif
2457 }
2458 /*
2459 * Copyright (c) 2003 by Hewlett-Packard Company. All rights reserved.
2460 *
2461 * This file is covered by the GNU general public license, version 2.
2462 * see COPYING for details.
2463 */
2464
2465 /* Some basic sanity tests. These do not test the barrier semantics. */
2466
2467 #undef TA_assert
2468 #define TA_assert(e) \
2469 if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _acquire_read)\n", \
2470 __FILE__, __LINE__), exit(1); }
2471
2472 #undef MISSING
2473 #define MISSING(name) \
2474 printf("Missing: %s\n", #name "_acquire_read")
2475
test_atomic_acquire_read(void)2476 void test_atomic_acquire_read(void)
2477 {
2478 AO_t x;
2479 unsigned char b;
2480 unsigned short s;
2481 unsigned int zz;
2482 # if defined(AO_HAVE_test_and_set_acquire_read)
2483 AO_TS_t z = AO_TS_INITIALIZER;
2484 # endif
2485 # if defined(AO_HAVE_double_compare_and_swap_acquire_read) \
2486 || defined(AO_HAVE_double_load_acquire_read) \
2487 || defined(AO_HAVE_double_store_acquire_read)
2488 AO_double_t old_w;
2489 AO_double_t new_w;
2490 # endif
2491 # if defined(AO_HAVE_compare_and_swap_double_acquire_read) \
2492 || defined(AO_HAVE_compare_double_and_swap_double_acquire_read) \
2493 || defined(AO_HAVE_double_compare_and_swap_acquire_read)
2494 AO_double_t w;
2495 w.AO_val1 = 0;
2496 w.AO_val2 = 0;
2497 # endif
2498
2499 # if defined(AO_HAVE_nop_acquire_read)
2500 AO_nop_acquire_read();
2501 # elif !defined(AO_HAVE_nop) || !defined(AO_HAVE_nop_full) \
2502 || !defined(AO_HAVE_nop_read) || !defined(AO_HAVE_nop_write)
2503 MISSING(AO_nop);
2504 # endif
2505 # if defined(AO_HAVE_store_acquire_read)
2506 AO_store_acquire_read(&x, 13);
2507 TA_assert (x == 13);
2508 # else
2509 # if !defined(AO_HAVE_store) || !defined(AO_HAVE_store_full) \
2510 || !defined(AO_HAVE_store_release) \
2511 || !defined(AO_HAVE_store_release_write) \
2512 || !defined(AO_HAVE_store_write)
2513 MISSING(AO_store);
2514 # endif
2515 x = 13;
2516 # endif
2517 # if defined(AO_HAVE_load_acquire_read)
2518 TA_assert(AO_load_acquire_read(&x) == 13);
2519 # elif !defined(AO_HAVE_load) || !defined(AO_HAVE_load_acquire) \
2520 || !defined(AO_HAVE_load_acquire_read) \
2521 || !defined(AO_HAVE_load_dd_acquire_read) \
2522 || !defined(AO_HAVE_load_full) || !defined(AO_HAVE_load_read)
2523 MISSING(AO_load);
2524 # endif
2525 # if defined(AO_HAVE_test_and_set_acquire_read)
2526 assert(AO_test_and_set_acquire_read(&z) == AO_TS_CLEAR);
2527 assert(AO_test_and_set_acquire_read(&z) == AO_TS_SET);
2528 assert(AO_test_and_set_acquire_read(&z) == AO_TS_SET);
2529 AO_CLEAR(&z);
2530 # else
2531 MISSING(AO_test_and_set);
2532 # endif
2533 # if defined(AO_HAVE_fetch_and_add_acquire_read)
2534 TA_assert(AO_fetch_and_add_acquire_read(&x, 42) == 13);
2535 TA_assert(AO_fetch_and_add_acquire_read(&x, (AO_t)(-42)) == 55);
2536 # else
2537 MISSING(AO_fetch_and_add);
2538 # endif
2539 # if defined(AO_HAVE_fetch_and_add1_acquire_read)
2540 TA_assert(AO_fetch_and_add1_acquire_read(&x) == 13);
2541 # else
2542 MISSING(AO_fetch_and_add1);
2543 ++x;
2544 # endif
2545 # if defined(AO_HAVE_fetch_and_sub1_acquire_read)
2546 TA_assert(AO_fetch_and_sub1_acquire_read(&x) == 14);
2547 # else
2548 MISSING(AO_fetch_and_sub1);
2549 --x;
2550 # endif
2551 # if defined(AO_HAVE_short_store_acquire_read)
2552 AO_short_store_acquire_read(&s, 13);
2553 # else
2554 # if !defined(AO_HAVE_short_store) || !defined(AO_HAVE_short_store_full) \
2555 || !defined(AO_HAVE_short_store_release) \
2556 || !defined(AO_HAVE_short_store_release_write) \
2557 || !defined(AO_HAVE_short_store_write)
2558 MISSING(AO_short_store);
2559 # endif
2560 s = 13;
2561 # endif
2562 # if defined(AO_HAVE_short_load_acquire_read)
2563 TA_assert(AO_short_load(&s) == 13);
2564 # elif !defined(AO_HAVE_short_load) || !defined(AO_HAVE_short_load_acquire) \
2565 || !defined(AO_HAVE_short_load_acquire_read) \
2566 || !defined(AO_HAVE_short_load_dd_acquire_read) \
2567 || !defined(AO_HAVE_short_load_full) \
2568 || !defined(AO_HAVE_short_load_read)
2569 MISSING(AO_short_load);
2570 # endif
2571 # if defined(AO_HAVE_short_fetch_and_add_acquire_read)
2572 TA_assert(AO_short_fetch_and_add_acquire_read(&s, 42) == 13);
2573 TA_assert(AO_short_fetch_and_add_acquire_read(&s, (unsigned short)-42) == 55);
2574 # else
2575 MISSING(AO_short_fetch_and_add);
2576 # endif
2577 # if defined(AO_HAVE_short_fetch_and_add1_acquire_read)
2578 TA_assert(AO_short_fetch_and_add1_acquire_read(&s) == 13);
2579 # else
2580 MISSING(AO_short_fetch_and_add1);
2581 ++s;
2582 # endif
2583 # if defined(AO_HAVE_short_fetch_and_sub1_acquire_read)
2584 TA_assert(AO_short_fetch_and_sub1_acquire_read(&s) == 14);
2585 # else
2586 MISSING(AO_short_fetch_and_sub1);
2587 --s;
2588 # endif
2589 # if defined(AO_HAVE_char_store_acquire_read)
2590 AO_char_store_acquire_read(&b, 13);
2591 # else
2592 # if !defined(AO_HAVE_char_store) || !defined(AO_HAVE_char_store_full) \
2593 || !defined(AO_HAVE_char_store_release) \
2594 || !defined(AO_HAVE_char_store_release_write) \
2595 || !defined(AO_HAVE_char_store_write)
2596 MISSING(AO_char_store);
2597 # endif
2598 b = 13;
2599 # endif
2600 # if defined(AO_HAVE_char_load_acquire_read)
2601 TA_assert(AO_char_load(&b) == 13);
2602 # elif !defined(AO_HAVE_char_load) || !defined(AO_HAVE_char_load_acquire) \
2603 || !defined(AO_HAVE_char_load_acquire_read) \
2604 || !defined(AO_HAVE_char_load_dd_acquire_read) \
2605 || !defined(AO_HAVE_char_load_full) || !defined(AO_HAVE_char_load_read)
2606 MISSING(AO_char_load);
2607 # endif
2608 # if defined(AO_HAVE_char_fetch_and_add_acquire_read)
2609 TA_assert(AO_char_fetch_and_add_acquire_read(&b, 42) == 13);
2610 TA_assert(AO_char_fetch_and_add_acquire_read(&b, (unsigned char)-42) == 55);
2611 # else
2612 MISSING(AO_char_fetch_and_add);
2613 # endif
2614 # if defined(AO_HAVE_char_fetch_and_add1_acquire_read)
2615 TA_assert(AO_char_fetch_and_add1_acquire_read(&b) == 13);
2616 # else
2617 MISSING(AO_char_fetch_and_add1);
2618 ++b;
2619 # endif
2620 # if defined(AO_HAVE_char_fetch_and_sub1_acquire_read)
2621 TA_assert(AO_char_fetch_and_sub1_acquire_read(&b) == 14);
2622 # else
2623 MISSING(AO_char_fetch_and_sub1);
2624 --b;
2625 # endif
2626 # if defined(AO_HAVE_int_store_acquire_read)
2627 AO_int_store_acquire_read(&zz, 13);
2628 # else
2629 # if !defined(AO_HAVE_int_store) || !defined(AO_HAVE_int_store_full) \
2630 || !defined(AO_HAVE_int_store_release) \
2631 || !defined(AO_HAVE_int_store_release_write) \
2632 || !defined(AO_HAVE_int_store_write)
2633 MISSING(AO_int_store);
2634 # endif
2635 zz = 13;
2636 # endif
2637 # if defined(AO_HAVE_int_load_acquire_read)
2638 TA_assert(AO_int_load(&zz) == 13);
2639 # elif !defined(AO_HAVE_int_load) || !defined(AO_HAVE_int_load_acquire) \
2640 || !defined(AO_HAVE_int_load_acquire_read) \
2641 || !defined(AO_HAVE_int_load_dd_acquire_read) \
2642 || !defined(AO_HAVE_int_load_full) || !defined(AO_HAVE_int_load_read)
2643 MISSING(AO_int_load);
2644 # endif
2645 # if defined(AO_HAVE_int_fetch_and_add_acquire_read)
2646 TA_assert(AO_int_fetch_and_add_acquire_read(&zz, 42) == 13);
2647 TA_assert(AO_int_fetch_and_add_acquire_read(&zz, (unsigned int)-42) == 55);
2648 # else
2649 MISSING(AO_int_fetch_and_add);
2650 # endif
2651 # if defined(AO_HAVE_int_fetch_and_add1_acquire_read)
2652 TA_assert(AO_int_fetch_and_add1_acquire_read(&zz) == 13);
2653 # else
2654 MISSING(AO_int_fetch_and_add1);
2655 ++zz;
2656 # endif
2657 # if defined(AO_HAVE_int_fetch_and_sub1_acquire_read)
2658 TA_assert(AO_int_fetch_and_sub1_acquire_read(&zz) == 14);
2659 # else
2660 MISSING(AO_int_fetch_and_sub1);
2661 --zz;
2662 # endif
2663 # if defined(AO_HAVE_compare_and_swap_acquire_read)
2664 TA_assert(!AO_compare_and_swap_acquire_read(&x, 14, 42));
2665 TA_assert(x == 13);
2666 TA_assert(AO_compare_and_swap_acquire_read(&x, 13, 42));
2667 TA_assert(x == 42);
2668 # else
2669 MISSING(AO_compare_and_swap);
2670 if (x == 13) x = 42;
2671 # endif
2672 # if defined(AO_HAVE_or_acquire_read)
2673 AO_or_acquire_read(&x, 66);
2674 TA_assert(x == 106);
2675 # else
2676 MISSING(AO_or);
2677 x |= 66;
2678 # endif
2679 # if defined(AO_HAVE_xor_acquire_read)
2680 AO_xor_acquire_read(&x, 181);
2681 TA_assert(x == 223);
2682 # else
2683 MISSING(AO_xor);
2684 x ^= 181;
2685 # endif
2686 # if defined(AO_HAVE_and_acquire_read)
2687 AO_and_acquire_read(&x, 57);
2688 TA_assert(x == 25);
2689 # else
2690 MISSING(AO_and);
2691 x &= 57;
2692 # endif
2693 # if defined(AO_HAVE_fetch_compare_and_swap_acquire_read)
2694 TA_assert(AO_fetch_compare_and_swap_acquire_read(&x, 14, 117) == 25);
2695 TA_assert(x == 25);
2696 TA_assert(AO_fetch_compare_and_swap_acquire_read(&x, 25, 117) == 25);
2697 TA_assert(x == 117);
2698 # else
2699 MISSING(AO_fetch_compare_and_swap);
2700 if (x == 25) x = 117;
2701 # endif
2702 # if defined(AO_HAVE_double_load_acquire_read)
2703 old_w.AO_val1 = 3316;
2704 old_w.AO_val2 = 2921;
2705 new_w = AO_double_load_acquire_read(&old_w);
2706 TA_assert(new_w.AO_val1 == 3316 && new_w.AO_val2 == 2921);
2707 # elif !defined(AO_HAVE_double_load) \
2708 || !defined(AO_HAVE_double_load_acquire) \
2709 || !defined(AO_HAVE_double_load_acquire_read) \
2710 || !defined(AO_HAVE_double_load_dd_acquire_read) \
2711 || !defined(AO_HAVE_double_load_full) \
2712 || !defined(AO_HAVE_double_load_read)
2713 MISSING(AO_double_load);
2714 # endif
2715 # if defined(AO_HAVE_double_store_acquire_read)
2716 new_w.AO_val1 = 1375;
2717 new_w.AO_val2 = 8243;
2718 AO_double_store_acquire_read(&old_w, new_w);
2719 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
2720 AO_double_store_acquire_read(&old_w, new_w);
2721 TA_assert(old_w.AO_val1 == 1375 && old_w.AO_val2 == 8243);
2722 new_w.AO_val1 ^= old_w.AO_val1;
2723 new_w.AO_val2 ^= old_w.AO_val2;
2724 AO_double_store_acquire_read(&old_w, new_w);
2725 TA_assert(old_w.AO_val1 == 0 && old_w.AO_val2 == 0);
2726 # elif !defined(AO_HAVE_double_store) \
2727 || !defined(AO_HAVE_double_store_full) \
2728 || !defined(AO_HAVE_double_store_release) \
2729 || !defined(AO_HAVE_double_store_release_write) \
2730 || !defined(AO_HAVE_double_store_write)
2731 MISSING(AO_double_store);
2732 # endif
2733 # if defined(AO_HAVE_compare_double_and_swap_double_acquire_read)
2734 TA_assert(!AO_compare_double_and_swap_double_acquire_read(&w, 17, 42, 12, 13));
2735 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2736 TA_assert(AO_compare_double_and_swap_double_acquire_read(&w, 0, 0, 12, 13));
2737 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2738 TA_assert(!AO_compare_double_and_swap_double_acquire_read(&w, 12, 14, 64, 33));
2739 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2740 TA_assert(!AO_compare_double_and_swap_double_acquire_read(&w, 11, 13, 85, 82));
2741 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2742 TA_assert(!AO_compare_double_and_swap_double_acquire_read(&w, 13, 12, 17, 42));
2743 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2744 TA_assert(AO_compare_double_and_swap_double_acquire_read(&w, 12, 13, 17, 42));
2745 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
2746 TA_assert(AO_compare_double_and_swap_double_acquire_read(&w, 17, 42, 0, 0));
2747 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2748 # else
2749 MISSING(AO_compare_double_and_swap_double);
2750 # endif
2751 # if defined(AO_HAVE_compare_and_swap_double_acquire_read)
2752 TA_assert(!AO_compare_and_swap_double_acquire_read(&w, 17, 12, 13));
2753 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2754 TA_assert(AO_compare_and_swap_double_acquire_read(&w, 0, 12, 13));
2755 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2756 TA_assert(!AO_compare_and_swap_double_acquire_read(&w, 13, 12, 33));
2757 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2758 TA_assert(!AO_compare_and_swap_double_acquire_read(&w, 1213, 48, 86));
2759 TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
2760 TA_assert(AO_compare_and_swap_double_acquire_read(&w, 12, 17, 42));
2761 TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
2762 TA_assert(AO_compare_and_swap_double_acquire_read(&w, 17, 0, 0));
2763 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2764 # else
2765 MISSING(AO_compare_and_swap_double);
2766 # endif
2767 # if defined(AO_HAVE_double_compare_and_swap_acquire_read)
2768 old_w.AO_val1 = 4116;
2769 old_w.AO_val2 = 2121;
2770 new_w.AO_val1 = 8537;
2771 new_w.AO_val2 = 6410;
2772 TA_assert(!AO_double_compare_and_swap_acquire_read(&w, old_w, new_w));
2773 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2774 TA_assert(AO_double_compare_and_swap_acquire_read(&w, w, new_w));
2775 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2776 old_w.AO_val1 = new_w.AO_val1;
2777 old_w.AO_val2 = 29;
2778 new_w.AO_val1 = 820;
2779 new_w.AO_val2 = 5917;
2780 TA_assert(!AO_double_compare_and_swap_acquire_read(&w, old_w, new_w));
2781 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2782 old_w.AO_val1 = 11;
2783 old_w.AO_val2 = 6410;
2784 new_w.AO_val1 = 3552;
2785 new_w.AO_val2 = 1746;
2786 TA_assert(!AO_double_compare_and_swap_acquire_read(&w, old_w, new_w));
2787 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2788 old_w.AO_val1 = old_w.AO_val2;
2789 old_w.AO_val2 = 8537;
2790 new_w.AO_val1 = 4116;
2791 new_w.AO_val2 = 2121;
2792 TA_assert(!AO_double_compare_and_swap_acquire_read(&w, old_w, new_w));
2793 TA_assert(w.AO_val1 == 8537 && w.AO_val2 == 6410);
2794 old_w.AO_val1 = old_w.AO_val2;
2795 old_w.AO_val2 = 6410;
2796 new_w.AO_val1 = 1;
2797 TA_assert(AO_double_compare_and_swap_acquire_read(&w, old_w, new_w));
2798 TA_assert(w.AO_val1 == 1 && w.AO_val2 == 2121);
2799 old_w.AO_val1 = new_w.AO_val1;
2800 old_w.AO_val2 = w.AO_val2;
2801 new_w.AO_val1--;
2802 new_w.AO_val2 = 0;
2803 TA_assert(AO_double_compare_and_swap_acquire_read(&w, old_w, new_w));
2804 TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
2805 # else
2806 MISSING(AO_double_compare_and_swap);
2807 # endif
2808 }
2809