libstdc++-v3/testsuite/29_atomics/atomic_float/1.cc

   1 // Copyright (C) 2019-2022 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-add-options ieee }
  20 // { dg-do run { target c++2a } }
  21
  22 #include <atomic>
  23 #include <testsuite_hooks.h>
  24
  25 void
  26 test01()
  27 {
  28   const auto mo = std::memory_order_relaxed;
  29   bool ok;
  30   float expected;
  31
  32   if constexpr (std::atomic<float>::is_always_lock_free)
  33   {
  34     std::atomic<float> a0;
  35     std::atomic<float> a1(1.0f);
  36     ok = a0.is_lock_free();
  37     a0 = a1.load();
  38     VERIFY( a0.load() == a1.load() );
  39     VERIFY( a0.load(mo) == a0.load() );
  40     a0.store(0.5f);
  41     a1.store(0.5f, mo);
  42     VERIFY( a0.load() == a1.load() );
  43     auto f0 = a0.exchange(12.5f);
  44     auto f1 = a1.exchange(12.5f, mo);
  45     VERIFY( a0 == 12.5f );
  46     VERIFY( a0.load() == a1.load() );
  47     VERIFY( f0 == 0.5f );
  48     VERIFY( f0 == f1 );
  49
  50     expected = 12.5f;
  51     while (!a0.compare_exchange_weak(expected, 1.6f, mo, mo))
  52     { /* weak form can fail spuriously */ }
  53     VERIFY( a0.load() == 1.6f );
  54     VERIFY( expected == 12.5f );
  55     expected = 1.5f;
  56     ok = a1.compare_exchange_weak(expected, 1.6f, mo, mo);
  57     VERIFY( !ok && a1.load() == 12.5f && expected == 12.5f );
  58     VERIFY( expected == 12.5f );
  59     expected = 1.6f;
  60     ok = a0.compare_exchange_strong(expected, 3.2f, mo, mo);
  61     VERIFY( ok && a0.load() == 3.2f );
  62     VERIFY( expected == 1.6f );
  63     expected = 1.5f;
  64     ok = a1.compare_exchange_strong(expected, 3.2f, mo, mo);
  65     VERIFY( !ok && a1.load() == 12.5f && expected == 12.5f );
  66
  67     expected = 3.2f;
  68     while (!a0.compare_exchange_weak(expected, .64f))
  69     { /* weak form can fail spuriously */ }
  70     VERIFY( a0.load() == .64f );
  71     expected = 12.5f;
  72     while (!a1.compare_exchange_weak(expected, 1.6f, mo))
  73     { /* weak form can fail spuriously */ }
  74     VERIFY( a1.load() == 1.6f );
  75     expected = 0.5f;
  76     ok = a0.compare_exchange_weak(expected, 3.2f);
  77     VERIFY( !ok && a0.load() == .64f && expected == .64f );
  78     expected = 0.5f;
  79     ok = a1.compare_exchange_weak(expected, 3.2f, mo);
  80     VERIFY( !ok && a1.load() == 1.6f && expected == 1.6f );
  81
  82     expected = .64f;
  83     ok = a0.compare_exchange_strong(expected, 12.8f);
  84     VERIFY( ok && a0.load() == 12.8f );
  85     expected = 1.6f;
  86     ok = a1.compare_exchange_strong(expected, 2.56f, mo);
  87     VERIFY( ok && a1.load() == 2.56f );
  88     expected = 0.5f;
  89     ok = a0.compare_exchange_strong(expected, 3.2f);
  90     VERIFY( !ok && a0.load() == 12.8f && expected == 12.8f );
  91     expected = 0.5f;
  92     ok = a1.compare_exchange_strong(expected, 3.2f, mo);
  93     VERIFY( !ok && a1.load() == 2.56f && expected == 2.56f );
  94
  95     f0 = a0.fetch_add(1.2f);
  96     VERIFY( f0 == 12.8f );
  97     VERIFY( a0 == 14.0f );
  98     f1 = a1.fetch_add(2.4f, mo);
  99     VERIFY( f1 == 2.56f );
 100     VERIFY( a1 == 4.96f );
 101
 102     f0 = a0.fetch_sub(1.2f);
 103     VERIFY( f0 == 14.0f );
 104     VERIFY( a0 == 12.8f );
 105     f1 = a1.fetch_sub(3.5f, mo);
 106     VERIFY( f1 == 4.96f );
 107     VERIFY( a1 == 1.46f );
 108
 109     f0 = a0 += 1.2f;
 110     VERIFY( f0 == 14.0f );
 111     VERIFY( a0 == 14.0f );
 112
 113     f0 = a0 -= 0.8f;
 114     VERIFY( f0 == 13.2f );
 115     VERIFY( a0 == 13.2f );
 116   }
 117
 118   // Repeat for volatile std::atomic<float>
 119   if constexpr (std::atomic<float>::is_always_lock_free)
 120   {
 121     volatile std::atomic<float> a0;
 122     volatile std::atomic<float> a1(1.0f);
 123     ok = a0.is_lock_free();
 124     a0 = a1.load();
 125     VERIFY( a0.load() == a1.load() );
 126     VERIFY( a0.load(mo) == a0.load() );
 127     a0.store(0.5f);
 128     a1.store(0.5f, mo);
 129     VERIFY( a0.load() == a1.load() );
 130     auto f0 = a0.exchange(12.5f);
 131     auto f1 = a1.exchange(12.5f, mo);
 132     VERIFY( a0 == 12.5f );
 133     VERIFY( a0.load() == a1.load() );
 134     VERIFY( f0 == 0.5f );
 135     VERIFY( f0 == f1 );
 136
 137     expected = 12.5f;
 138     while (!a0.compare_exchange_weak(expected, 1.6f, mo, mo))
 139     { /* weak form can fail spuriously */ }
 140     VERIFY( a0.load() == 1.6f );
 141     VERIFY( expected == 12.5f );
 142     expected = 1.5f;
 143     ok = a1.compare_exchange_weak(expected, 1.6f, mo, mo);
 144     VERIFY( !ok && a1.load() == 12.5f && expected == 12.5f );
 145     VERIFY( expected == 12.5f );
 146     expected = 1.6f;
 147     ok = a0.compare_exchange_strong(expected, 3.2f, mo, mo);
 148     VERIFY( ok && a0.load() == 3.2f );
 149     VERIFY( expected == 1.6f );
 150     expected = 1.5f;
 151     ok = a1.compare_exchange_strong(expected, 3.2f, mo, mo);
 152     VERIFY( !ok && a1.load() == 12.5f && expected == 12.5f );
 153
 154     expected = 3.2f;
 155     while (!a0.compare_exchange_weak(expected, .64f))
 156     { /* weak form can fail spuriously */ }
 157     VERIFY( a0.load() == .64f );
 158     expected = 12.5f;
 159     while (!a1.compare_exchange_weak(expected, 1.6f, mo))
 160     { /* weak form can fail spuriously */ }
 161     VERIFY( a1.load() == 1.6f );
 162     expected = 0.5f;
 163     ok = a0.compare_exchange_weak(expected, 3.2f);
 164     VERIFY( !ok && a0.load() == .64f && expected == .64f );
 165     expected = 0.5f;
 166     ok = a1.compare_exchange_weak(expected, 3.2f, mo);
 167     VERIFY( !ok && a1.load() == 1.6f && expected == 1.6f );
 168
 169     expected = .64f;
 170     ok = a0.compare_exchange_strong(expected, 12.8f);
 171     VERIFY( ok && a0.load() == 12.8f );
 172     expected = 1.6f;
 173     ok = a1.compare_exchange_strong(expected, 2.56f, mo);
 174     VERIFY( ok && a1.load() == 2.56f );
 175     expected = 0.5f;
 176     ok = a0.compare_exchange_strong(expected, 3.2f);
 177     VERIFY( !ok && a0.load() == 12.8f && expected == 12.8f );
 178     expected = 0.5f;
 179     ok = a1.compare_exchange_strong(expected, 3.2f, mo);
 180     VERIFY( !ok && a1.load() == 2.56f && expected == 2.56f );
 181
 182     f0 = a0.fetch_add(1.2f);
 183     VERIFY( f0 == 12.8f );
 184     VERIFY( a0 == 14.0f );
 185     f1 = a1.fetch_add(2.4f, mo);
 186     VERIFY( f1 == 2.56f );
 187     VERIFY( a1 == 4.96f );
 188
 189     f0 = a0.fetch_sub(1.2f);
 190     VERIFY( f0 == 14.0f );
 191     VERIFY( a0 == 12.8f );
 192     f1 = a1.fetch_sub(3.5f, mo);
 193     VERIFY( f1 == 4.96f );
 194     VERIFY( a1 == 1.46f );
 195
 196     f0 = a0 += 1.2f;
 197     VERIFY( f0 == 14.0f );
 198     VERIFY( a0 == 14.0f );
 199
 200     f0 = a0 -= 0.8f;
 201     VERIFY( f0 == 13.2f );
 202     VERIFY( a0 == 13.2f );
 203   }
 204 }
 205
 206 void
 207 test02()
 208 {
 209   const auto mo = std::memory_order_relaxed;
 210   bool ok;
 211   double expected;
 212
 213   if constexpr (std::atomic<double>::is_always_lock_free)
 214   {
 215     std::atomic<double> a0;
 216     std::atomic<double> a1(1.0);
 217     ok = a0.is_lock_free();
 218     a0 = a1.load();
 219     VERIFY( a0.load() == a1.load() );
 220     VERIFY( a0.load(mo) == a0.load() );
 221     a0.store(0.5);
 222     a1.store(0.5, mo);
 223     VERIFY( a0.load() == a1.load() );
 224     auto f0 = a0.exchange(12.5);
 225     auto f1 = a1.exchange(12.5, mo);
 226     VERIFY( a0 == 12.5 );
 227     VERIFY( a0.load() == a1.load() );
 228     VERIFY( f0 == 0.5 );
 229     VERIFY( f0 == f1 );
 230
 231     expected = 12.5;
 232     while (!a0.compare_exchange_weak(expected, 1.6, mo, mo))
 233     { /* weak form can fail spuriously */ }
 234     VERIFY( a0.load() == 1.6 );
 235     VERIFY( expected == 12.5 );
 236     expected = 1.5;
 237     ok = a1.compare_exchange_weak(expected, 1.6, mo, mo);
 238     VERIFY( !ok && a1.load() == 12.5 && expected == 12.5 );
 239     VERIFY( expected == 12.5 );
 240     expected = 1.6;
 241     ok = a0.compare_exchange_strong(expected, 3.2, mo, mo);
 242     VERIFY( ok && a0.load() == 3.2 );
 243     VERIFY( expected == 1.6 );
 244     expected = 1.5;
 245     ok = a1.compare_exchange_strong(expected, 3.2, mo, mo);
 246     VERIFY( !ok && a1.load() == 12.5 && expected == 12.5 );
 247
 248     expected = 3.2;
 249     while (!a0.compare_exchange_weak(expected, .64))
 250     { /* weak form can fail spuriously */ }
 251     VERIFY( a0.load() == .64 );
 252     expected = 12.5;
 253     while (!a1.compare_exchange_weak(expected, 1.6, mo))
 254     { /* weak form can fail spuriously */ }
 255     VERIFY( a1.load() == 1.6 );
 256     expected = 0.5;
 257     ok = a0.compare_exchange_weak(expected, 3.2);
 258     VERIFY( !ok && a0.load() == .64 && expected == .64 );
 259     expected = 0.5;
 260     ok = a1.compare_exchange_weak(expected, 3.2, mo);
 261     VERIFY( !ok && a1.load() == 1.6 && expected == 1.6 );
 262
 263     expected = .64;
 264     ok = a0.compare_exchange_strong(expected, 12.8);
 265     VERIFY( ok && a0.load() == 12.8 );
 266     expected = 1.6;
 267     ok = a1.compare_exchange_strong(expected, 2.56, mo);
 268     VERIFY( ok && a1.load() == 2.56 );
 269     expected = 0.5;
 270     ok = a0.compare_exchange_strong(expected, 3.2);
 271     VERIFY( !ok && a0.load() == 12.8 && expected == 12.8 );
 272     expected = 0.5;
 273     ok = a1.compare_exchange_strong(expected, 3.2, mo);
 274     VERIFY( !ok && a1.load() == 2.56 && expected == 2.56 );
 275
 276     f0 = a0.fetch_add(1.2);
 277     VERIFY( f0 == 12.8 );
 278     VERIFY( a0 == 14.0 );
 279     f1 = a1.fetch_add(2.4, mo);
 280     VERIFY( f1 == 2.56 );
 281     VERIFY( a1 == 4.96 );
 282
 283     f0 = a0.fetch_sub(1.2);
 284     VERIFY( f0 == 14.0 );
 285     VERIFY( a0 == 12.8 );
 286     f1 = a1.fetch_sub(3.5, mo);
 287     VERIFY( f1 == 4.96 );
 288     VERIFY( a1 == 1.46 );
 289
 290     f0 = a0 += 1.2;
 291     VERIFY( f0 == 14.0 );
 292     VERIFY( a0 == 14.0 );
 293
 294     f0 = a0 -= 0.8;
 295     VERIFY( f0 == 13.2 );
 296     VERIFY( a0 == 13.2 );
 297   }
 298
 299   // Repeat for volatile std::atomic<double>
 300   if constexpr (std::atomic<double>::is_always_lock_free)
 301   {
 302     volatile std::atomic<double> a0;
 303     volatile std::atomic<double> a1(1.0);
 304     ok = a0.is_lock_free();
 305     a0 = a1.load();
 306     VERIFY( a0.load() == a1.load() );
 307     VERIFY( a0.load(mo) == a0.load() );
 308     a0.store(0.5);
 309     a1.store(0.5, mo);
 310     VERIFY( a0.load() == a1.load() );
 311     auto f0 = a0.exchange(12.5);
 312     auto f1 = a1.exchange(12.5, mo);
 313     VERIFY( a0 == 12.5 );
 314     VERIFY( a0.load() == a1.load() );
 315     VERIFY( f0 == 0.5 );
 316     VERIFY( f0 == f1 );
 317
 318     expected = 12.5;
 319     while (!a0.compare_exchange_weak(expected, 1.6, mo, mo))
 320     { /* weak form can fail spuriously */ }
 321     VERIFY( a0.load() == 1.6 );
 322     VERIFY( expected == 12.5 );
 323     expected = 1.5;
 324     ok = a1.compare_exchange_weak(expected, 1.6, mo, mo);
 325     VERIFY( !ok && a1.load() == 12.5 && expected == 12.5 );
 326     VERIFY( expected == 12.5 );
 327     expected = 1.6;
 328     ok = a0.compare_exchange_strong(expected, 3.2, mo, mo);
 329     VERIFY( ok && a0.load() == 3.2 );
 330     VERIFY( expected == 1.6 );
 331     expected = 1.5;
 332     ok = a1.compare_exchange_strong(expected, 3.2, mo, mo);
 333     VERIFY( !ok && a1.load() == 12.5 && expected == 12.5 );
 334
 335     expected = 3.2;
 336     while (!a0.compare_exchange_weak(expected, .64))
 337     { /* weak form can fail spuriously */ }
 338     VERIFY( a0.load() == .64 );
 339     expected = 12.5;
 340     while (!a1.compare_exchange_weak(expected, 1.6, mo))
 341     { /* weak form can fail spuriously */ }
 342     VERIFY( a1.load() == 1.6 );
 343     expected = 0.5;
 344     ok = a0.compare_exchange_weak(expected, 3.2);
 345     VERIFY( !ok && a0.load() == .64 && expected == .64 );
 346     expected = 0.5;
 347     ok = a1.compare_exchange_weak(expected, 3.2, mo);
 348     VERIFY( !ok && a1.load() == 1.6 && expected == 1.6 );
 349
 350     expected = .64;
 351     ok = a0.compare_exchange_strong(expected, 12.8);
 352     VERIFY( ok && a0.load() == 12.8 );
 353     expected = 1.6;
 354     ok = a1.compare_exchange_strong(expected, 2.56, mo);
 355     VERIFY( ok && a1.load() == 2.56 );
 356     expected = 0.5;
 357     ok = a0.compare_exchange_strong(expected, 3.2);
 358     VERIFY( !ok && a0.load() == 12.8 && expected == 12.8 );
 359     expected = 0.5;
 360     ok = a1.compare_exchange_strong(expected, 3.2, mo);
 361     VERIFY( !ok && a1.load() == 2.56 && expected == 2.56 );
 362
 363     f0 = a0.fetch_add(1.2);
 364     VERIFY( f0 == 12.8 );
 365     VERIFY( a0 == 14.0 );
 366     f1 = a1.fetch_add(2.4, mo);
 367     VERIFY( f1 == 2.56 );
 368     VERIFY( a1 == 4.96 );
 369
 370     f0 = a0.fetch_sub(1.2);
 371     VERIFY( f0 == 14.0 );
 372     VERIFY( a0 == 12.8 );
 373     f1 = a1.fetch_sub(3.5, mo);
 374     VERIFY( f1 == 4.96 );
 375     VERIFY( a1 == 1.46 );
 376
 377     f0 = a0 += 1.2;
 378     VERIFY( f0 == 14.0 );
 379     VERIFY( a0 == 14.0 );
 380
 381     f0 = a0 -= 0.8;
 382     VERIFY( f0 == 13.2 );
 383     VERIFY( a0 == 13.2 );
 384   }
 385 }
 386
 387 void
 388 test03()
 389 {
 390   const auto mo = std::memory_order_relaxed;
 391   bool ok;
 392   long double expected;
 393
 394   if constexpr (std::atomic<long double>::is_always_lock_free)
 395   {
 396     std::atomic<long double> a0;
 397     std::atomic<long double> a1(1.0l);
 398     ok = a0.is_lock_free();
 399     a0 = a1.load();
 400     VERIFY( a0.load() == a1.load() );
 401     VERIFY( a0.load(mo) == a0.load() );
 402     a0.store(0.5l);
 403     a1.store(0.5l, mo);
 404     VERIFY( a0.load() == a1.load() );
 405     auto f0 = a0.exchange(12.5l);
 406     auto f1 = a1.exchange(12.5l, mo);
 407     VERIFY( a0 == 12.5l );
 408     VERIFY( a0.load() == a1.load() );
 409     VERIFY( f0 == 0.5l );
 410     VERIFY( f0 == f1 );
 411
 412     expected = 12.5l;
 413     while (!a0.compare_exchange_weak(expected, 1.6l, mo, mo))
 414     { /* weak form can fail spuriously */ }
 415     VERIFY( a0.load() == 1.6l );
 416     VERIFY( expected == 12.5l );
 417     expected = 1.5l;
 418     ok = a1.compare_exchange_weak(expected, 1.6l, mo, mo);
 419     VERIFY( !ok && a1.load() == 12.5l && expected == 12.5l );
 420     VERIFY( expected == 12.5l );
 421     expected = 1.6l;
 422     ok = a0.compare_exchange_strong(expected, 3.2l, mo, mo);
 423     VERIFY( ok && a0.load() == 3.2l );
 424     VERIFY( expected == 1.6l );
 425     expected = 1.5l;
 426     ok = a1.compare_exchange_strong(expected, 3.2l, mo, mo);
 427     VERIFY( !ok && a1.load() == 12.5l && expected == 12.5l );
 428
 429     expected = 3.2l;
 430     while (!a0.compare_exchange_weak(expected, .64l))
 431     { /* weak form can fail spuriously */ }
 432     VERIFY( a0.load() == .64l );
 433     expected = 12.5l;
 434     while (!a1.compare_exchange_weak(expected, 1.6l, mo))
 435     { /* weak form can fail spuriously */ }
 436     VERIFY( a1.load() == 1.6l );
 437     expected = 0.5l;
 438     ok = a0.compare_exchange_weak(expected, 3.2l);
 439     VERIFY( !ok && a0.load() == .64l && expected == .64l );
 440     expected = 0.5l;
 441     ok = a1.compare_exchange_weak(expected, 3.2l, mo);
 442     VERIFY( !ok && a1.load() == 1.6l && expected == 1.6l );
 443
 444     expected = .64l;
 445     ok = a0.compare_exchange_strong(expected, 12.8l);
 446     VERIFY( ok && a0.load() == 12.8l );
 447     expected = 1.6l;
 448     ok = a1.compare_exchange_strong(expected, 2.56l, mo);
 449     VERIFY( ok && a1.load() == 2.56l );
 450     expected = 0.5l;
 451     ok = a0.compare_exchange_strong(expected, 3.2l);
 452     VERIFY( !ok && a0.load() == 12.8l && expected == 12.8l );
 453     expected = 0.5l;
 454     ok = a1.compare_exchange_strong(expected, 3.2l, mo);
 455     VERIFY( !ok && a1.load() == 2.56l && expected == 2.56l );
 456
 457     a1 = a0 = 0.5l;
 458     f0 = a0.fetch_add(0.25l);
 459     VERIFY( f0 == 0.5l );
 460     VERIFY( a0 == 0.75l );
 461     f1 = a1.fetch_add(0.25l, mo);
 462     VERIFY( f1 == 0.5l );
 463     VERIFY( a1 == 0.75l );
 464
 465     f0 = a0.fetch_sub(0.5l);
 466     VERIFY( f0 == 0.75l );
 467     VERIFY( a0 == 0.25l );
 468     f1 = a1.fetch_sub(0.5l, mo);
 469     VERIFY( f1 == 0.75l );
 470     VERIFY( a1 == 0.25l );
 471
 472     f0 = a0 += 0.75l;
 473     VERIFY( f0 == 1.0l );
 474     VERIFY( a0 == 1.0l );
 475
 476     f0 = a0 -= 0.5l;
 477     VERIFY( f0 == 0.5l );
 478     VERIFY( a0 == 0.5l );
 479   }
 480
 481   // Repeat for volatile std::atomic<long double>
 482   if constexpr (std::atomic<long double>::is_always_lock_free)
 483   {
 484     volatile std::atomic<long double> a0;
 485     volatile std::atomic<long double> a1(1.0l);
 486     ok = a0.is_lock_free();
 487     a0 = a1.load();
 488     VERIFY( a0.load() == a1.load() );
 489     VERIFY( a0.load(mo) == a0.load() );
 490     a0.store(0.5l);
 491     a1.store(0.5l, mo);
 492     VERIFY( a0.load() == a1.load() );
 493     auto f0 = a0.exchange(12.5l);
 494     auto f1 = a1.exchange(12.5l, mo);
 495     VERIFY( a0 == 12.5l );
 496     VERIFY( a0.load() == a1.load() );
 497     VERIFY( f0 == 0.5l );
 498     VERIFY( f0 == f1 );
 499
 500     expected = 12.5l;
 501     while (!a0.compare_exchange_weak(expected, 1.6l, mo, mo))
 502     { /* weak form can fail spuriously */ }
 503     VERIFY( a0.load() == 1.6l );
 504     VERIFY( expected == 12.5l );
 505     expected = 1.5l;
 506     ok = a1.compare_exchange_weak(expected, 1.6l, mo, mo);
 507     VERIFY( !ok && a1.load() == 12.5l && expected == 12.5l );
 508     VERIFY( expected == 12.5l );
 509     expected = 1.6l;
 510     ok = a0.compare_exchange_strong(expected, 3.2l, mo, mo);
 511     VERIFY( ok && a0.load() == 3.2l );
 512     VERIFY( expected == 1.6l );
 513     expected = 1.5l;
 514     ok = a1.compare_exchange_strong(expected, 3.2l, mo, mo);
 515     VERIFY( !ok && a1.load() == 12.5l && expected == 12.5l );
 516
 517     expected = 3.2l;
 518     while (!a0.compare_exchange_weak(expected, .64l))
 519     { /* weak form can fail spuriously */ }
 520     VERIFY( a0.load() == .64l );
 521     expected = 12.5l;
 522     while (!a1.compare_exchange_weak(expected, 1.6l, mo))
 523     { /* weak form can fail spuriously */ }
 524     VERIFY( a1.load() == 1.6l );
 525     expected = 0.5l;
 526     ok = a0.compare_exchange_weak(expected, 3.2l);
 527     VERIFY( !ok && a0.load() == .64l && expected == .64l );
 528     expected = 0.5l;
 529     ok = a1.compare_exchange_weak(expected, 3.2l, mo);
 530     VERIFY( !ok && a1.load() == 1.6l && expected == 1.6l );
 531
 532     expected = .64l;
 533     ok = a0.compare_exchange_strong(expected, 12.8l);
 534     VERIFY( ok && a0.load() == 12.8l );
 535     expected = 1.6l;
 536     ok = a1.compare_exchange_strong(expected, 2.56l, mo);
 537     VERIFY( ok && a1.load() == 2.56l );
 538     expected = 0.5l;
 539     ok = a0.compare_exchange_strong(expected, 3.2l);
 540     VERIFY( !ok && a0.load() == 12.8l && expected == 12.8l );
 541     expected = 0.5l;
 542     ok = a1.compare_exchange_strong(expected, 3.2l, mo);
 543     VERIFY( !ok && a1.load() == 2.56l && expected == 2.56l );
 544
 545     a1 = a0 = 0.5l;
 546     f0 = a0.fetch_add(0.25l);
 547     VERIFY( f0 == 0.5l );
 548     VERIFY( a0 == 0.75l );
 549     f1 = a1.fetch_add(0.25l, mo);
 550     VERIFY( f1 == 0.5l );
 551     VERIFY( a1 == 0.75l );
 552
 553     f0 = a0.fetch_sub(0.5l);
 554     VERIFY( f0 == 0.75l );
 555     VERIFY( a0 == 0.25l );
 556     f1 = a1.fetch_sub(0.5l, mo);
 557     VERIFY( f1 == 0.75l );
 558     VERIFY( a1 == 0.25l );
 559
 560     f0 = a0 += 0.75l;
 561     VERIFY( f0 == 1.0l );
 562     VERIFY( a0 == 1.0l );
 563
 564     f0 = a0 -= 0.5l;
 565     VERIFY( f0 == 0.5l );
 566     VERIFY( a0 == 0.5l );
 567   }
 568 }
 569
 570 int
 571 main()
 572 {
 573   test01();
 574   test02();
 575   test03();
 576 }