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

   1 // Copyright (C) 2019-2020 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-options "-std=gnu++2a" }
  19 // { dg-do run { target c++2a } }
  20
  21 #include <atomic>
  22 #include <testsuite_hooks.h>
  23
  24 void
  25 test01()
  26 {
  27   float value;
  28   if constexpr (std::atomic_ref<float>::is_always_lock_free)
  29   {
  30     const auto mo = std::memory_order_relaxed;
  31     std::atomic_ref<float> a(value);
  32     bool ok = a.is_lock_free();
  33     if constexpr (std::atomic_ref<float>::is_always_lock_free)
  34       VERIFY( ok );
  35     a = 1.6f;
  36     VERIFY( a.load() == 1.6f );
  37     a.store(0.8f);
  38     VERIFY( a.load(mo) == 0.8f );
  39     a.store(3.2f, mo);
  40     VERIFY( a.load() == 3.2f );
  41     auto v = a.exchange(6.4f);
  42     VERIFY( a == 6.4f );
  43     VERIFY( v == 3.2f );
  44     v = a.exchange(1.28f, mo);
  45     VERIFY( a == 1.28f );
  46     VERIFY( v == 6.4f );
  47
  48     auto expected = a.load();
  49     while (!a.compare_exchange_weak(expected, 25.6f, mo, mo))
  50     { /* weak form can fail spuriously */ }
  51     VERIFY( a.load() == 25.6f );
  52     VERIFY( expected == 1.28f );
  53     expected = 3.2f;
  54     ok = a.compare_exchange_weak(expected, 51.2f, mo, mo);
  55     VERIFY( !ok && a.load() == 25.6f && expected == 25.6f );
  56     ok = a.compare_exchange_strong(expected, 51.2f, mo, mo);
  57     VERIFY( ok && a.load() == 51.2f && expected == 25.6f );
  58     expected = 0.0f;
  59     ok = a.compare_exchange_strong(expected, 1.28f, mo, mo);
  60     VERIFY( !ok && a.load() == 51.2f && expected == 51.2f );
  61
  62     while (!a.compare_exchange_weak(expected, 25.6f))
  63     { /* weak form can fail spuriously */ }
  64     VERIFY( a.load() == 25.6f  && expected == 51.2f );
  65     expected = a.load();
  66     while (!a.compare_exchange_weak(expected, 10.24f, mo))
  67     { /* weak form can fail spuriously */ }
  68     VERIFY( a.load() == 10.24f && expected == 25.6f );
  69     expected = a.load() + 1;
  70     ok = a.compare_exchange_weak(expected, 40.96f);
  71     VERIFY( !ok && a.load() == 10.24f && expected == 10.24f );
  72     expected = a.load() + 1;
  73     ok = a.compare_exchange_weak(expected, 40.96f, mo);
  74     VERIFY( !ok && a.load() == 10.24f && expected == 10.24f );
  75
  76     ok = a.compare_exchange_strong(expected, 1.024f);
  77     VERIFY( ok && a.load() == 1.024f && expected == 10.24f );
  78     expected = a.load();
  79     ok = a.compare_exchange_strong(expected, 204.8f, mo);
  80     VERIFY( ok && a.load() == 204.8f && expected == 1.024f );
  81     expected = a.load() + 1;
  82     ok = a.compare_exchange_strong(expected, 6.4f);
  83     VERIFY( !ok && a.load() == 204.8f && expected == 204.8f );
  84     expected = a.load() + 1;
  85     ok = a.compare_exchange_strong(expected, 6.4f, mo);
  86     VERIFY( !ok && a.load() == 204.8f && expected == 204.8f );
  87
  88     v = a.fetch_add(3.2f);
  89     VERIFY( v == 204.8f );
  90     VERIFY( a == 208.0f );
  91     v = a.fetch_add(-8.5f, mo);
  92     VERIFY( v == 208.0f );
  93     VERIFY( a == 199.5f );
  94
  95     v = a.fetch_sub(109.5f);
  96     VERIFY( v == 199.5f );
  97     VERIFY( a == 90.0f );
  98     v = a.fetch_sub(2, mo);
  99     VERIFY( v == 90.0f );
 100     VERIFY( a == 88.0f );
 101
 102     v = a += 5.0f;
 103     VERIFY( v == 93.0f );
 104     VERIFY( a == 93.0f );
 105
 106     v = a -= 6.5f;
 107     VERIFY( v == 86.5f );
 108     VERIFY( a == 86.5f );
 109   }
 110
 111   if constexpr (std::atomic_ref<float>::is_always_lock_free)
 112     VERIFY( value == 86.5f );
 113 }
 114
 115 void
 116 test02()
 117 {
 118   double value;
 119   if constexpr (std::atomic_ref<double>::is_always_lock_free)
 120   {
 121     const auto mo = std::memory_order_relaxed;
 122     std::atomic_ref<double> a(value);
 123     bool ok = a.is_lock_free();
 124     if constexpr (std::atomic_ref<double>::is_always_lock_free)
 125       VERIFY( ok );
 126     a = 1.6;
 127     VERIFY( a.load() == 1.6 );
 128     a.store(0.8);
 129     VERIFY( a.load(mo) == 0.8 );
 130     a.store(3.2, mo);
 131     VERIFY( a.load() == 3.2 );
 132     auto v = a.exchange(6.4);
 133     VERIFY( a == 6.4 );
 134     VERIFY( v == 3.2 );
 135     v = a.exchange(1.28, mo);
 136     VERIFY( a == 1.28 );
 137     VERIFY( v == 6.4 );
 138
 139     auto expected = a.load();
 140     while (!a.compare_exchange_weak(expected, 25.6, mo, mo))
 141     { /* weak form can fail spuriously */ }
 142     VERIFY( a.load() == 25.6 );
 143     VERIFY( expected == 1.28 );
 144     expected = 3.2;
 145     ok = a.compare_exchange_weak(expected, 51.2, mo, mo);
 146     VERIFY( !ok && a.load() == 25.6 && expected == 25.6 );
 147     ok = a.compare_exchange_strong(expected, 51.2, mo, mo);
 148     VERIFY( ok && a.load() == 51.2 && expected == 25.6 );
 149     expected = 0.0;
 150     ok = a.compare_exchange_strong(expected, 1.28, mo, mo);
 151     VERIFY( !ok && a.load() == 51.2 && expected == 51.2 );
 152
 153     while (!a.compare_exchange_weak(expected, 25.6))
 154     { /* weak form can fail spuriously */ }
 155     VERIFY( a.load() == 25.6  && expected == 51.2 );
 156     expected = a.load();
 157     while (!a.compare_exchange_weak(expected, 10.24, mo))
 158     { /* weak form can fail spuriously */ }
 159     VERIFY( a.load() == 10.24 && expected == 25.6 );
 160     expected = a.load() + 1;
 161     ok = a.compare_exchange_weak(expected, 40.96);
 162     VERIFY( !ok && a.load() == 10.24 && expected == 10.24 );
 163     expected = a.load() + 1;
 164     ok = a.compare_exchange_weak(expected, 40.96, mo);
 165     VERIFY( !ok && a.load() == 10.24 && expected == 10.24 );
 166
 167     ok = a.compare_exchange_strong(expected, 1.024);
 168     VERIFY( ok && a.load() == 1.024 && expected == 10.24 );
 169     expected = a.load();
 170     ok = a.compare_exchange_strong(expected, 204.8, mo);
 171     VERIFY( ok && a.load() == 204.8 && expected == 1.024 );
 172     expected = a.load() + 1;
 173     ok = a.compare_exchange_strong(expected, 6.4);
 174     VERIFY( !ok && a.load() == 204.8 && expected == 204.8 );
 175     expected = a.load() + 1;
 176     ok = a.compare_exchange_strong(expected, 6.4, mo);
 177     VERIFY( !ok && a.load() == 204.8 && expected == 204.8 );
 178
 179     v = a.fetch_add(3.2);
 180     VERIFY( v == 204.8 );
 181     VERIFY( a == 208.0 );
 182     v = a.fetch_add(-8.5, mo);
 183     VERIFY( v == 208.0 );
 184     VERIFY( a == 199.5 );
 185
 186     v = a.fetch_sub(109.5);
 187     VERIFY( v == 199.5 );
 188     VERIFY( a == 90.0 );
 189     v = a.fetch_sub(2, mo);
 190     VERIFY( v == 90.0 );
 191     VERIFY( a == 88.0 );
 192
 193     v = a += 5.0;
 194     VERIFY( v == 93.0 );
 195     VERIFY( a == 93.0 );
 196
 197     v = a -= 6.5;
 198     VERIFY( v == 86.5 );
 199     VERIFY( a == 86.5 );
 200   }
 201
 202   if constexpr (std::atomic_ref<double>::is_always_lock_free)
 203     VERIFY( value == 86.5 );
 204 }
 205
 206 void
 207 test03()
 208 {
 209   long double value;
 210   if constexpr (std::atomic_ref<long double>::is_always_lock_free)
 211   {
 212     const auto mo = std::memory_order_relaxed;
 213     std::atomic_ref<long double> a(value);
 214     bool ok = a.is_lock_free();
 215     if constexpr (std::atomic_ref<long double>::is_always_lock_free)
 216       VERIFY( ok );
 217     a = 1.6l;
 218     VERIFY( a.load() == 1.6l );
 219     a.store(0.8l);
 220     VERIFY( a.load(mo) == 0.8l );
 221     a.store(3.2l, mo);
 222     VERIFY( a.load() == 3.2l );
 223     auto v = a.exchange(6.4l);
 224     VERIFY( a == 6.4l );
 225     VERIFY( v == 3.2l );
 226     v = a.exchange(1.28l, mo);
 227     VERIFY( a == 1.28l );
 228     VERIFY( v == 6.4l );
 229
 230     auto expected = a.load();
 231     while (!a.compare_exchange_weak(expected, 25.6l, mo, mo))
 232     { /* weak form can fail spuriously */ }
 233     VERIFY( a.load() == 25.6l );
 234     VERIFY( expected == 1.28l );
 235     expected = 3.2l;
 236     ok = a.compare_exchange_weak(expected, 51.2l, mo, mo);
 237     VERIFY( !ok && a.load() == 25.6l && expected == 25.6l );
 238     ok = a.compare_exchange_strong(expected, 51.2l, mo, mo);
 239     VERIFY( ok && a.load() == 51.2l && expected == 25.6l );
 240     expected = 0.0l;
 241     ok = a.compare_exchange_strong(expected, 1.28l, mo, mo);
 242     VERIFY( !ok && a.load() == 51.2l && expected == 51.2l );
 243
 244     while (!a.compare_exchange_weak(expected, 25.6l))
 245     { /* weak form can fail spuriously */ }
 246     VERIFY( a.load() == 25.6l  && expected == 51.2l );
 247     expected = a.load();
 248     while (!a.compare_exchange_weak(expected, 10.24l, mo))
 249     { /* weak form can fail spuriously */ }
 250     VERIFY( a.load() == 10.24l && expected == 25.6l );
 251     expected = a.load() + 1;
 252     ok = a.compare_exchange_weak(expected, 40.96l);
 253     VERIFY( !ok && a.load() == 10.24l && expected == 10.24l );
 254     expected = a.load() + 1;
 255     ok = a.compare_exchange_weak(expected, 40.96l, mo);
 256     VERIFY( !ok && a.load() == 10.24l && expected == 10.24l );
 257
 258     ok = a.compare_exchange_strong(expected, 1.024l);
 259     VERIFY( ok && a.load() == 1.024l && expected == 10.24l );
 260     expected = a.load();
 261     ok = a.compare_exchange_strong(expected, 204.8l, mo);
 262     VERIFY( ok && a.load() == 204.8l && expected == 1.024l );
 263     expected = a.load() + 1;
 264     ok = a.compare_exchange_strong(expected, 6.4l);
 265     VERIFY( !ok && a.load() == 204.8l && expected == 204.8l );
 266     expected = a.load() + 1;
 267     ok = a.compare_exchange_strong(expected, 6.4l, mo);
 268     VERIFY( !ok && a.load() == 204.8l && expected == 204.8l );
 269
 270     v = a.fetch_add(3.2l);
 271     VERIFY( v == 204.8l );
 272     VERIFY( a == 208.0l );
 273     v = a.fetch_add(-8.5l, mo);
 274     VERIFY( v == 208.0l );
 275     VERIFY( a == 199.5l );
 276
 277     v = a.fetch_sub(109.5l);
 278     VERIFY( v == 199.5l );
 279     VERIFY( a == 90.0l );
 280     v = a.fetch_sub(2, mo);
 281     VERIFY( v == 90.0l );
 282     VERIFY( a == 88.0l );
 283
 284     v = a += 5.0l;
 285     VERIFY( v == 93.0l );
 286     VERIFY( a == 93.0l );
 287
 288     v = a -= 6.5l;
 289     VERIFY( v == 86.5l );
 290     VERIFY( a == 86.5l );
 291   }
 292
 293   if constexpr (std::atomic_ref<long double>::is_always_lock_free)
 294     VERIFY( value == 86.5l );
 295 }
 296
 297 void
 298 test04()
 299 {
 300   if constexpr (std::atomic_ref<float>::is_always_lock_free)
 301   {
 302     float i = 0;
 303     float* ptr = 0;
 304     std::atomic_ref<float*> a0(ptr);
 305     std::atomic_ref<float*> a1(ptr);
 306     std::atomic_ref<float*> a2(a0);
 307     a0 = &i;
 308     VERIFY( a1 == &i );
 309     VERIFY( a2 == &i );
 310   }
 311 }
 312
 313 int
 314 main()
 315 {
 316   test01();
 317   test02();
 318   test03();
 319   test04();
 320 }