test/silly/tst-atomic.c

   1 /* Tests for atomic.h macros.
   2    Copyright (C) 2003-2015 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <stdio.h>
  21 #include <atomic.h>
  22
  23 #ifndef atomic_t
  24 # define atomic_t int
  25 #endif
  26
  27 #define CHK2(f,a1,a2,rv,new_mem) \
  28         retval = f(&mem, a1, a2); \
  29         if (retval != rv) { \
  30                 printf("%s(mem, %lu, %lu): retval %lu != expected %lu\n", \
  31                         #f, a1, a2, retval, rv); \
  32                 ret = 1; \
  33         } \
  34         if (mem != new_mem) { \
  35                 printf("%s(mem, %lu, %lu):    mem %lu != expected %lu\n", \
  36                         #f, a1, a2, mem, new_mem); \
  37                 ret = 1; \
  38         }
  39 #define CHK1(f,a1,rv,new_mem) \
  40         retval = f(&mem, a1); \
  41         if (retval != rv) { \
  42                 printf("%s(mem, %lu): retval %lu != expected %lu\n", \
  43                         #f, a1, retval, rv); \
  44                 ret = 1; \
  45         } \
  46         if (mem != new_mem) { \
  47                 printf("%s(mem, %lu):    mem %lu != expected %lu\n", \
  48                         #f, a1, mem, new_mem); \
  49                 ret = 1; \
  50         }
  51 #define CHK0(f,rv,new_mem) \
  52         retval = f(&mem); \
  53         if (retval != rv) { \
  54                 printf("%s(mem): retval %lu != expected %lu\n", \
  55                         #f, retval, rv); \
  56                 ret = 1; \
  57         } \
  58         if (mem != new_mem) { \
  59                 printf("%s(mem):    mem %lu != expected %lu\n", \
  60                         #f, mem, new_mem); \
  61                 ret = 1; \
  62         }
  63
  64 /* Test various atomic.h macros.  */
  65 static int
  66 do_test (void)
  67 {
  68   atomic_t mem, expected, retval;
  69   int ret = 0;
  70
  71 #ifdef atomic_compare_and_exchange_val_acq
  72   mem = 24;
  73   CHK2(atomic_compare_and_exchange_val_acq, 35, 24, 24, 35);
  74   mem = 12;
  75   CHK2(atomic_compare_and_exchange_val_acq, 10, 15, 12, 12);
  76   mem = -15;
  77   CHK2(atomic_compare_and_exchange_val_acq, -56, -15, -15, -56);
  78   mem = -1;
  79   CHK2(atomic_compare_and_exchange_val_acq, 17, 0, -1, -1);
  80 #endif
  81
  82   mem = 24;
  83   CHK2(atomic_compare_and_exchange_bool_acq, 35, 24, 0, 35);
  84   mem = 12;
  85   CHK2(atomic_compare_and_exchange_bool_acq, 10, 15, 1, 12);
  86   mem = -15;
  87   CHK2(atomic_compare_and_exchange_bool_acq, -56, -15, 0, -56);
  88   mem = -1;
  89   CHK2(atomic_compare_and_exchange_bool_acq, 17, 0, 1, -1);
  90
  91   mem = 64;
  92   CHK1(atomic_exchange_acq, 31, 64, 31);
  93   mem = 2;
  94   CHK1(atomic_exchange_and_add, 11, 2, 13);
  95   mem = 2;
  96   CHK1(atomic_exchange_and_add_acq, 11, 2, 13);
  97   mem = 2;
  98   CHK1(atomic_exchange_and_add_rel, 11, 2, 13);
  99
 100   mem = -21;
 101   atomic_add (&mem, 22);
 102   if (mem != 1)
 103     {
 104       printf ("atomic_add(mem, 22):    mem %lu != expected 1\n", mem);
 105       ret = 1;
 106     }
 107
 108   mem = -1;
 109   atomic_increment (&mem);
 110   if (mem != 0)
 111     {
 112       printf ("atomic_increment(mem):    mem %lu != expected 0\n", mem);
 113       ret = 1;
 114     }
 115
 116   mem = 2;
 117   if ((retval = atomic_increment_val (&mem)) != 3)
 118     {
 119       printf ("atomic_increment_val(mem): retval %lu != expected 3\n", retval);
 120       ret = 1;
 121     }
 122
 123   mem = 0;
 124   CHK0(atomic_increment_and_test, 0, 1);
 125   mem = 35;
 126   CHK0(atomic_increment_and_test, 0, 36);
 127   mem = -1;
 128   CHK0(atomic_increment_and_test, 1, 0);
 129   mem = 17;
 130   atomic_decrement (&mem);
 131   if (mem != 16)
 132     {
 133       printf ("atomic_increment(mem):    mem %lu != expected 16\n", mem);
 134       ret = 1;
 135     }
 136
 137   if ((retval = atomic_decrement_val (&mem)) != 15)
 138     {
 139       printf ("atomic_decrement_val(mem): retval %lu != expected 15\n", retval);
 140       ret = 1;
 141     }
 142
 143   mem = 0;
 144   CHK0(atomic_decrement_and_test, 0, -1);
 145
 146   mem = 15;
 147   CHK0(atomic_decrement_and_test, 0, 14);
 148   mem = 1;
 149   CHK0(atomic_decrement_and_test, 1, 0);
 150   mem = 1;
 151   if (atomic_decrement_if_positive (&mem) != 1
 152       || mem != 0)
 153     {
 154       puts ("atomic_decrement_if_positive test 1 failed");
 155       ret = 1;
 156     }
 157
 158   mem = 0;
 159   if (atomic_decrement_if_positive (&mem) != 0
 160       || mem != 0)
 161     {
 162       puts ("atomic_decrement_if_positive test 2 failed");
 163       ret = 1;
 164     }
 165
 166   mem = -1;
 167   if (atomic_decrement_if_positive (&mem) != -1
 168       || mem != -1)
 169     {
 170       puts ("atomic_decrement_if_positive test 3 failed");
 171       ret = 1;
 172     }
 173
 174   mem = -12;
 175   if (! atomic_add_negative (&mem, 10)
 176       || mem != -2)
 177     {
 178       puts ("atomic_add_negative test 1 failed");
 179       ret = 1;
 180     }
 181
 182   mem = 0;
 183   if (atomic_add_negative (&mem, 100)
 184       || mem != 100)
 185     {
 186       puts ("atomic_add_negative test 2 failed");
 187       ret = 1;
 188     }
 189
 190   mem = 15;
 191   if (atomic_add_negative (&mem, -10)
 192       || mem != 5)
 193     {
 194       puts ("atomic_add_negative test 3 failed");
 195       ret = 1;
 196     }
 197
 198   mem = -12;
 199   if (atomic_add_negative (&mem, 14)
 200       || mem != 2)
 201     {
 202       puts ("atomic_add_negative test 4 failed");
 203       ret = 1;
 204     }
 205
 206   mem = 0;
 207   if (! atomic_add_negative (&mem, -1)
 208       || mem != -1)
 209     {
 210       puts ("atomic_add_negative test 5 failed");
 211       ret = 1;
 212     }
 213
 214   mem = -31;
 215   if (atomic_add_negative (&mem, 31)
 216       || mem != 0)
 217     {
 218       puts ("atomic_add_negative test 6 failed");
 219       ret = 1;
 220     }
 221
 222   mem = -34;
 223   if (atomic_add_zero (&mem, 31)
 224       || mem != -3)
 225     {
 226       puts ("atomic_add_zero test 1 failed");
 227       ret = 1;
 228     }
 229
 230   mem = -36;
 231   if (! atomic_add_zero (&mem, 36)
 232       || mem != 0)
 233     {
 234       puts ("atomic_add_zero test 2 failed");
 235       ret = 1;
 236     }
 237
 238   mem = 113;
 239   if (atomic_add_zero (&mem, -13)
 240       || mem != 100)
 241     {
 242       puts ("atomic_add_zero test 3 failed");
 243       ret = 1;
 244     }
 245
 246   mem = -18;
 247   if (atomic_add_zero (&mem, 20)
 248       || mem != 2)
 249     {
 250       puts ("atomic_add_zero test 4 failed");
 251       ret = 1;
 252     }
 253
 254   mem = 10;
 255   if (atomic_add_zero (&mem, -20)
 256       || mem != -10)
 257     {
 258       puts ("atomic_add_zero test 5 failed");
 259       ret = 1;
 260     }
 261
 262   mem = 10;
 263   if (! atomic_add_zero (&mem, -10)
 264       || mem != 0)
 265     {
 266       puts ("atomic_add_zero test 6 failed");
 267       ret = 1;
 268     }
 269
 270   mem = 0;
 271   atomic_bit_set (&mem, 1);
 272   if (mem != 2)
 273     {
 274       puts ("atomic_bit_set test 1 failed");
 275       ret = 1;
 276     }
 277
 278   mem = 8;
 279   atomic_bit_set (&mem, 3);
 280   if (mem != 8)
 281     {
 282       puts ("atomic_bit_set test 2 failed");
 283       ret = 1;
 284     }
 285
 286 #ifdef TEST_ATOMIC64
 287   mem = 16;
 288   atomic_bit_set (&mem, 35);
 289   if (mem != 0x800000010LL)
 290     {
 291       puts ("atomic_bit_set test 3 failed");
 292       ret = 1;
 293     }
 294 #endif
 295
 296   mem = 0;
 297   if (atomic_bit_test_set (&mem, 1)
 298       || mem != 2)
 299     {
 300       puts ("atomic_bit_test_set test 1 failed");
 301       ret = 1;
 302     }
 303
 304   mem = 8;
 305   if (! atomic_bit_test_set (&mem, 3)
 306       || mem != 8)
 307     {
 308       puts ("atomic_bit_test_set test 2 failed");
 309       ret = 1;
 310     }
 311
 312 #ifdef TEST_ATOMIC64
 313   mem = 16;
 314   if (atomic_bit_test_set (&mem, 35)
 315       || mem != 0x800000010LL)
 316     {
 317       puts ("atomic_bit_test_set test 3 failed");
 318       ret = 1;
 319     }
 320
 321   mem = 0x100000000LL;
 322   if (! atomic_bit_test_set (&mem, 32)
 323       || mem != 0x100000000LL)
 324     {
 325       puts ("atomic_bit_test_set test 4 failed");
 326       ret = 1;
 327     }
 328 #endif
 329
 330 #ifdef catomic_compare_and_exchange_val_acq
 331   mem = 24;
 332   if (catomic_compare_and_exchange_val_acq (&mem, 35, 24) != 24
 333       || mem != 35)
 334     {
 335       puts ("catomic_compare_and_exchange_val_acq test 1 failed");
 336       ret = 1;
 337     }
 338
 339   mem = 12;
 340   if (catomic_compare_and_exchange_val_acq (&mem, 10, 15) != 12
 341       || mem != 12)
 342     {
 343       puts ("catomic_compare_and_exchange_val_acq test 2 failed");
 344       ret = 1;
 345     }
 346
 347   mem = -15;
 348   if (catomic_compare_and_exchange_val_acq (&mem, -56, -15) != -15
 349       || mem != -56)
 350     {
 351       puts ("catomic_compare_and_exchange_val_acq test 3 failed");
 352       ret = 1;
 353     }
 354
 355   mem = -1;
 356   if (catomic_compare_and_exchange_val_acq (&mem, 17, 0) != -1
 357       || mem != -1)
 358     {
 359       puts ("catomic_compare_and_exchange_val_acq test 4 failed");
 360       ret = 1;
 361     }
 362 #endif
 363
 364   mem = 24;
 365   if (catomic_compare_and_exchange_bool_acq (&mem, 35, 24)
 366       || mem != 35)
 367     {
 368       puts ("catomic_compare_and_exchange_bool_acq test 1 failed");
 369       ret = 1;
 370     }
 371
 372   mem = 12;
 373   if (! catomic_compare_and_exchange_bool_acq (&mem, 10, 15)
 374       || mem != 12)
 375     {
 376       puts ("catomic_compare_and_exchange_bool_acq test 2 failed");
 377       ret = 1;
 378     }
 379
 380   mem = -15;
 381   if (catomic_compare_and_exchange_bool_acq (&mem, -56, -15)
 382       || mem != -56)
 383     {
 384       puts ("catomic_compare_and_exchange_bool_acq test 3 failed");
 385       ret = 1;
 386     }
 387
 388   mem = -1;
 389   if (! catomic_compare_and_exchange_bool_acq (&mem, 17, 0)
 390       || mem != -1)
 391     {
 392       puts ("catomic_compare_and_exchange_bool_acq test 4 failed");
 393       ret = 1;
 394     }
 395
 396   mem = 2;
 397   if (catomic_exchange_and_add (&mem, 11) != 2
 398       || mem != 13)
 399     {
 400       puts ("catomic_exchange_and_add test failed");
 401       ret = 1;
 402     }
 403
 404   mem = -21;
 405   catomic_add (&mem, 22);
 406   if (mem != 1)
 407     {
 408       puts ("catomic_add test failed");
 409       ret = 1;
 410     }
 411
 412   mem = -1;
 413   catomic_increment (&mem);
 414   if (mem != 0)
 415     {
 416       puts ("catomic_increment test failed");
 417       ret = 1;
 418     }
 419
 420   mem = 2;
 421   if (catomic_increment_val (&mem) != 3)
 422     {
 423       puts ("catomic_increment_val test failed");
 424       ret = 1;
 425     }
 426
 427   mem = 17;
 428   catomic_decrement (&mem);
 429   if (mem != 16)
 430     {
 431       puts ("catomic_decrement test failed");
 432       ret = 1;
 433     }
 434
 435   if (catomic_decrement_val (&mem) != 15)
 436     {
 437       puts ("catomic_decrement_val test failed");
 438       ret = 1;
 439     }
 440
 441   /* Tests for C11-like atomics.  */
 442   mem = 11;
 443   if (atomic_load_relaxed (&mem) != 11 || atomic_load_acquire (&mem) != 11)
 444     {
 445       puts ("atomic_load_{relaxed,acquire} test failed");
 446       ret = 1;
 447     }
 448
 449   atomic_store_relaxed (&mem, 12);
 450   if (mem != 12)
 451     {
 452       puts ("atomic_store_relaxed test failed");
 453       ret = 1;
 454     }
 455   atomic_store_release (&mem, 13);
 456   if (mem != 13)
 457     {
 458       puts ("atomic_store_release test failed");
 459       ret = 1;
 460     }
 461
 462   mem = 14;
 463   expected = 14;
 464   if (!atomic_compare_exchange_weak_relaxed (&mem, &expected, 25)
 465       || mem != 25 || expected != 14)
 466     {
 467       puts ("atomic_compare_exchange_weak_relaxed test 1 failed");
 468       ret = 1;
 469     }
 470   if (atomic_compare_exchange_weak_relaxed (&mem, &expected, 14)
 471       || mem != 25 || expected != 25)
 472     {
 473       puts ("atomic_compare_exchange_weak_relaxed test 2 failed");
 474       ret = 1;
 475     }
 476   mem = 14;
 477   expected = 14;
 478   if (!atomic_compare_exchange_weak_acquire (&mem, &expected, 25)
 479       || mem != 25 || expected != 14)
 480     {
 481       puts ("atomic_compare_exchange_weak_acquire test 1 failed");
 482       ret = 1;
 483     }
 484   if (atomic_compare_exchange_weak_acquire (&mem, &expected, 14)
 485       || mem != 25 || expected != 25)
 486     {
 487       puts ("atomic_compare_exchange_weak_acquire test 2 failed");
 488       ret = 1;
 489     }
 490   mem = 14;
 491   expected = 14;
 492   if (!atomic_compare_exchange_weak_release (&mem, &expected, 25)
 493       || mem != 25 || expected != 14)
 494     {
 495       puts ("atomic_compare_exchange_weak_release test 1 failed");
 496       ret = 1;
 497     }
 498   if (atomic_compare_exchange_weak_release (&mem, &expected, 14)
 499       || mem != 25 || expected != 25)
 500     {
 501       puts ("atomic_compare_exchange_weak_release test 2 failed");
 502       ret = 1;
 503     }
 504
 505   mem = 23;
 506   if (atomic_exchange_acquire (&mem, 42) != 23 || mem != 42)
 507     {
 508       puts ("atomic_exchange_acquire test failed");
 509       ret = 1;
 510     }
 511   mem = 23;
 512   if (atomic_exchange_release (&mem, 42) != 23 || mem != 42)
 513     {
 514       puts ("atomic_exchange_release test failed");
 515       ret = 1;
 516     }
 517
 518   mem = 23;
 519   if (atomic_fetch_add_relaxed (&mem, 1) != 23 || mem != 24)
 520     {
 521       puts ("atomic_fetch_add_relaxed test failed");
 522       ret = 1;
 523     }
 524   mem = 23;
 525   if (atomic_fetch_add_acquire (&mem, 1) != 23 || mem != 24)
 526     {
 527       puts ("atomic_fetch_add_acquire test failed");
 528       ret = 1;
 529     }
 530   mem = 23;
 531   if (atomic_fetch_add_release (&mem, 1) != 23 || mem != 24)
 532     {
 533       puts ("atomic_fetch_add_release test failed");
 534       ret = 1;
 535     }
 536   mem = 23;
 537   if (atomic_fetch_add_acq_rel (&mem, 1) != 23 || mem != 24)
 538     {
 539       puts ("atomic_fetch_add_acq_rel test failed");
 540       ret = 1;
 541     }
 542
 543   mem = 3;
 544   if (atomic_fetch_and_acquire (&mem, 2) != 3 || mem != 2)
 545     {
 546       puts ("atomic_fetch_and_acquire test failed");
 547       ret = 1;
 548     }
 549
 550   mem = 4;
 551   if (atomic_fetch_or_relaxed (&mem, 2) != 4 || mem != 6)
 552     {
 553       puts ("atomic_fetch_or_relaxed test failed");
 554       ret = 1;
 555     }
 556   mem = 4;
 557   if (atomic_fetch_or_acquire (&mem, 2) != 4 || mem != 6)
 558     {
 559       puts ("atomic_fetch_or_acquire test failed");
 560       ret = 1;
 561     }
 562
 563   /* This is a single-threaded test, so we can't test the effects of the
 564      fences.  */
 565   atomic_thread_fence_acquire ();
 566   atomic_thread_fence_release ();
 567   atomic_thread_fence_seq_cst ();
 568
 569   return ret;
 570 }
 571
 572 #define TEST_FUNCTION do_test ()
 573 #include "../test-skeleton.c"