libstdc++-v3/testsuite/29_atomics/atomic_ref/integral.cc

   1 // Copyright (C) 2019-2024 Free Software Foundation, Inc.
   2 //
   3 // This file is part of the GNU ISO C++ Library.  This library is free
   4 // software; you can redistribute it and/or modify it under the
   5 // terms of the GNU General Public License as published by the
   6 // Free Software Foundation; either version 3, or (at your option)
   7 // any later version.
   8
   9 // This library is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13
  14 // You should have received a copy of the GNU General Public License along
  15 // with this library; see the file COPYING3.  If not see
  16 // <http://www.gnu.org/licenses/>.
  17
  18 // { dg-do run { target c++20 } }
  19 // { dg-require-atomic-cmpxchg-word "" }
  20 // { dg-add-options libatomic }
  21
  22 #include <atomic>
  23 #include <limits.h>
  24 #include <testsuite_hooks.h>
  25
  26 void
  27 test01()
  28 {
  29   int value;
  30
  31   {
  32     const auto mo = std::memory_order_relaxed;
  33     std::atomic_ref<int> a(value);
  34     bool ok = a.is_lock_free();
  35     if constexpr (std::atomic_ref<int>::is_always_lock_free)
  36       VERIFY( ok );
  37     a = 0;
  38     VERIFY( a.load() == 0 );
  39     VERIFY( a.load(mo) == 0 );
  40     a.store(1);
  41     VERIFY( a.load() == 1 );
  42     auto v = a.exchange(2);
  43     VERIFY( a == 2 );
  44     VERIFY( v == 1 );
  45     v = a.exchange(3, mo);
  46     VERIFY( a == 3 );
  47     VERIFY( v == 2 );
  48
  49     auto expected = a.load();
  50     while (!a.compare_exchange_weak(expected, 4, mo, mo))
  51     { /* weak form can fail spuriously */ }
  52     VERIFY( a.load() == 4 );
  53     VERIFY( expected == 3 );
  54     expected = 1;
  55     ok = a.compare_exchange_weak(expected, 5, mo, mo);
  56     VERIFY( !ok && a.load() == 4 && expected == 4 );
  57     ok = a.compare_exchange_strong(expected, 5, mo, mo);
  58     VERIFY( ok && a.load() == 5 && expected == 4 );
  59     expected = 0;
  60     ok = a.compare_exchange_strong(expected, 3, mo, mo);
  61     VERIFY( !ok && a.load() == 5 && expected == 5 );
  62
  63     while (!a.compare_exchange_weak(expected, 4))
  64     { /* weak form can fail spuriously */ }
  65     VERIFY( a.load() == 4  && expected == 5 );
  66     expected = a.load();
  67     while (!a.compare_exchange_weak(expected, 6, mo))
  68     { /* weak form can fail spuriously */ }
  69     VERIFY( a.load() == 6 && expected == 4 );
  70     expected = a.load() + 1;
  71     ok = a.compare_exchange_weak(expected, -8);
  72     VERIFY( !ok && a.load() == 6 && expected == 6 );
  73     expected = a.load() + 1;
  74     ok = a.compare_exchange_weak(expected, 8, mo);
  75     VERIFY( !ok && a.load() == 6 && expected == 6 );
  76
  77     ok = a.compare_exchange_strong(expected, -6);
  78     VERIFY( ok && a.load() == -6 && expected == 6 );
  79     expected = a.load();
  80     ok = a.compare_exchange_strong(expected, 7, mo);
  81     VERIFY( ok && a.load() == 7 && expected == -6 );
  82     expected = a.load() + 1;
  83     ok = a.compare_exchange_strong(expected, 2);
  84     VERIFY( !ok && a.load() == 7 && expected == 7 );
  85     expected = a.load() + 1;
  86     ok = a.compare_exchange_strong(expected, 2, mo);
  87     VERIFY( !ok && a.load() == 7 && expected == 7 );
  88
  89     v = a.fetch_add(2);
  90     VERIFY( v == 7 );
  91     VERIFY( a == 9 );
  92     v = a.fetch_add(-30, mo);
  93     VERIFY( v == 9 );
  94     VERIFY( a == -21 );
  95
  96     v = a.fetch_sub(3);
  97     VERIFY( v == -21 );
  98     VERIFY( a == -24 );
  99     v = a.fetch_sub(-41, mo);
 100     VERIFY( v == -24 );
 101     VERIFY( a == 17 );
 102
 103     v = a.fetch_and(0x101);
 104     VERIFY( v == 17 );
 105     VERIFY( a == 1 );
 106     a = 0x17;
 107     v = a.fetch_and(0x23, mo);
 108     VERIFY( v == 0x17 );
 109     VERIFY( a == 3 );
 110
 111     v = a.fetch_or(0x101);
 112     VERIFY( v == 3 );
 113     VERIFY( a == 0x103 );
 114     v = a.fetch_or(0x23, mo);
 115     VERIFY( v == 0x103 );
 116     VERIFY( a == 0x123 );
 117
 118     v = a.fetch_xor(0x101);
 119     VERIFY( v == 0x123 );
 120     VERIFY( a == 0x022 );
 121     v = a.fetch_xor(0x123, mo);
 122     VERIFY( v == 0x022 );
 123     VERIFY( a == 0x101 );
 124
 125     v = a++;
 126     VERIFY( v == 0x101 );
 127     VERIFY( a == 0x102 );
 128     v = a--;
 129     VERIFY( v == 0x102 );
 130     VERIFY( a == 0x101 );
 131     v = ++a;
 132     VERIFY( v == 0x102 );
 133     VERIFY( a == 0x102 );
 134     v = --a;
 135     VERIFY( v == 0x101 );
 136     VERIFY( a == 0x101 );
 137
 138     v = a += -10;
 139     VERIFY( v == 247 );
 140     VERIFY( a == 247 );
 141
 142     v = a -= 250;
 143     VERIFY( v == -3 );
 144     VERIFY( a == -3 );
 145
 146     a = 0x17;
 147     v = a &= 0x102;
 148     VERIFY( v == 2 );
 149     VERIFY( a == 2 );
 150
 151     v = a |= 0x101;
 152     VERIFY( v == 0x103 );
 153     VERIFY( a == 0x103 );
 154
 155     v = a ^= 0x121;
 156     VERIFY( v == 0x022 );
 157     VERIFY( a == 0x022 );
 158   }
 159
 160   VERIFY( value == 0x022 );
 161 }
 162
 163 void
 164 test02()
 165 {
 166   unsigned short value;
 167
 168   {
 169     const auto mo = std::memory_order_relaxed;
 170     std::atomic_ref<unsigned short> a(value);
 171     bool ok = a.is_lock_free();
 172     if constexpr (std::atomic_ref<unsigned short>::is_always_lock_free)
 173       VERIFY( ok );
 174     a = 0;
 175     VERIFY( a.load() == 0 );
 176     VERIFY( a.load(mo) == 0 );
 177     a.store(1);
 178     VERIFY( a.load() == 1 );
 179     auto v = a.exchange(2);
 180     VERIFY( a == 2 );
 181     VERIFY( v == 1 );
 182     v = a.exchange(3, mo);
 183     VERIFY( a == 3 );
 184     VERIFY( v == 2 );
 185
 186     auto expected = a.load();
 187     while (!a.compare_exchange_weak(expected, 4, mo, mo))
 188     { /* weak form can fail spuriously */ }
 189     VERIFY( a.load() == 4 );
 190     VERIFY( expected == 3 );
 191     expected = 1;
 192     ok = a.compare_exchange_weak(expected, 5, mo, mo);
 193     VERIFY( !ok && a.load() == 4 && expected == 4 );
 194     ok = a.compare_exchange_strong(expected, 5, mo, mo);
 195     VERIFY( ok && a.load() == 5 && expected == 4 );
 196     expected = 0;
 197     ok = a.compare_exchange_strong(expected, 3, mo, mo);
 198     VERIFY( !ok && a.load() == 5 && expected == 5 );
 199
 200     while (!a.compare_exchange_weak(expected, 4))
 201     { /* weak form can fail spuriously */ }
 202     VERIFY( a.load() == 4  && expected == 5 );
 203     expected = a.load();
 204     while (!a.compare_exchange_weak(expected, 6, mo))
 205     { /* weak form can fail spuriously */ }
 206     VERIFY( a.load() == 6 && expected == 4 );
 207     expected = a.load() + 1;
 208     ok = a.compare_exchange_weak(expected, -8);
 209     VERIFY( !ok && a.load() == 6 && expected == 6 );
 210     expected = a.load() + 1;
 211     ok = a.compare_exchange_weak(expected, 8, mo);
 212     VERIFY( !ok && a.load() == 6 && expected == 6 );
 213
 214     ok = a.compare_exchange_strong(expected, -6);
 215     VERIFY( ok && a.load() == (unsigned short)-6 && expected == 6 );
 216     expected = a.load();
 217     ok = a.compare_exchange_strong(expected, 7, mo);
 218     VERIFY( ok && a.load() == 7 && expected == (unsigned short)-6 );
 219     expected = a.load() + 1;
 220     ok = a.compare_exchange_strong(expected, 2);
 221     VERIFY( !ok && a.load() == 7 && expected == 7 );
 222     expected = a.load() + 1;
 223     ok = a.compare_exchange_strong(expected, 2, mo);
 224     VERIFY( !ok && a.load() == 7 && expected == 7 );
 225
 226     v = a.fetch_add(2);
 227     VERIFY( v == 7 );
 228     VERIFY( a == 9 );
 229     v = a.fetch_add(-30, mo);
 230     VERIFY( v == 9 );
 231     VERIFY( a == (unsigned short)-21 );
 232
 233     v = a.fetch_sub(3);
 234     VERIFY( v == (unsigned short)-21 );
 235     VERIFY( a == (unsigned short)-24 );
 236     v = a.fetch_sub((unsigned short)-41, mo);
 237     VERIFY( v == (unsigned short)-24 );
 238     VERIFY( a == 17 );
 239
 240     v = a.fetch_and(0x21);
 241     VERIFY( v == 17 );
 242     VERIFY( a == 1 );
 243     a = 0x17;
 244     v = a.fetch_and(0x23, mo);
 245     VERIFY( v == 0x17 );
 246     VERIFY( a == 3 );
 247
 248     v = a.fetch_or(0x21);
 249     VERIFY( v == 3 );
 250     VERIFY( a == 0x23 );
 251     v = a.fetch_or(0x44, mo);
 252     VERIFY( v == 0x23 );
 253     VERIFY( a == 0x67 );
 254
 255     v = a.fetch_xor(0x21);
 256     VERIFY( v == 0x67 );
 257     VERIFY( a == 0x46 );
 258     v = a.fetch_xor(0x12, mo);
 259     VERIFY( v == 0x46 );
 260     VERIFY( a == 0x54 );
 261
 262     v = a++;
 263     VERIFY( v == 0x54 );
 264     VERIFY( a == 0x55 );
 265     v = a--;
 266     VERIFY( v == 0x55 );
 267     VERIFY( a == 0x54 );
 268     v = ++a;
 269     VERIFY( v == 0x55 );
 270     VERIFY( a == 0x55 );
 271     v = --a;
 272     VERIFY( v == 0x54 );
 273     VERIFY( a == 0x54 );
 274
 275     v = a += -10;
 276     VERIFY( v == 0x4a );
 277     VERIFY( a == 0x4a );
 278
 279     v = a -= 15;
 280     VERIFY( v == 0x3b );
 281     VERIFY( a == 0x3b );
 282
 283     a = 0x17;
 284     v = a &= 0x12;
 285     VERIFY( v == 0x12 );
 286     VERIFY( a == 0x12 );
 287
 288     v = a |= 0x34;
 289     VERIFY( v == 0x36 );
 290     VERIFY( a == 0x36 );
 291
 292     v = a ^= 0x12;
 293     VERIFY( v == 0x24 );
 294     VERIFY( a == 0x24 );
 295   }
 296
 297   VERIFY( value == 0x24 );
 298 }
 299 void
 300 test03()
 301 {
 302   int i = 0;
 303   std::atomic_ref<int> a0(i);
 304   std::atomic_ref<int> a1(i);
 305   std::atomic_ref<int> a2(a0);
 306   a0 = 42;
 307   VERIFY( a1 == 42 );
 308   VERIFY( a2 == 42 );
 309 }
 310
 311 void
 312 test04()
 313 {
 314   int i = INT_MIN;
 315   std::atomic_ref<int> a(i);
 316   --a;
 317   VERIFY( a == INT_MAX );
 318   ++a;
 319   VERIFY( a == INT_MIN );
 320   a |= INT_MAX;
 321   VERIFY( a == -1 );
 322 }
 323
 324 int
 325 main()
 326 {
 327   test01();
 328   test02();
 329   test03();
 330   test04();
 331 }