RelacyAtomics.h

   1 /***************************************************************************
   2  *     Copyright (c) 2010, Ronald Landheer-Cieslak & Vlinder Software      *
   3  *                                                                         *
   4  * Ownership of Copyright                                                  *
   5  * ======================                                                  *
   6  * The copyright in this material (including without limitation the text,  *
   7  * computer code, artwork, photographs, images, music, audio material,     *
   8  * video material and audio-visual material) is owned by Ronald            *
   9  * Landheer-Cieslak and/or Vlinder Software.                               *
  10  *                                                                         *
  11  * Copyright license                                                       *
  12  * =================                                                       *
  13  * This program is free software: you can redistribute it and/or modify    *
  14  * it under the terms of the GNU General Public License as published by    *
  15  * the Free Software Foundation, version 3 of the License.                 *
  16  *                                                                         *
  17  * This program is distributed in the hope that it will be useful,         *
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  20  * GNU General Public License for more details.                            *
  21  *                                                                         *
  22  * You should have received a copy of the GNU General Public License       *
  23  * along with this program.  If not, see <http://www.gnu.org/licenses/>.   *
  24  ***************************************************************************/
  25 #ifndef VLINDER_ATOMICS_RELACYATOMICS_H
  26 #define VLINDER_ATOMICS_RELACYATOMICS_H
  27
  28 #ifdef _MSC_VER
  29 #pragma warning(push)
  30 #pragma warning(disable: 4996)
  31 #endif
  32 #include <relacy/atomic.hpp>
  33 #include <relacy/relacy_std.hpp>
  34 #include <relacy/atomic_fence.hpp>
  35 #ifdef _MSC_VER
  36 #pragma warning(pop)
  37 #endif
  38
  39 namespace Vlinder
  40 {
  41         namespace Atomics
  42         {
  43                 struct RelacyAtomics
  44                 {
  45                         enum MemoryOrder {
  46                                 memory_order_relaxed__ = rl::mo_relaxed,        // no operation orders memory
  47                                 memory_order_consume__ = rl::mo_consume,        // a load operation performs a consume operation on the affected memory location
  48                                 memory_order_acquire__ = rl::mo_acquire,        // a load operation performs an acquire operation on the affected memory location
  49                                 memory_order_release__ = rl::mo_release,        // a store operation performs a release operation on the affected memory location
  50                                 memory_order_acq_rel__ = rl::mo_acq_rel,        // a store operation performs a release operation on the affected memory location;
  51                                 // a load operation performs an acquire operation on the affected memory location
  52                                 memory_order_seq_cst__ = rl::mo_seq_cst,        // a store operation performs a release operation on the affected memory location;
  53                                 // a load operation performs an acquire operation on the affected memory location
  54                         };
  55
  56                         template < typename T >
  57                         struct Atomic
  58                                 : public rl::atomic< T >
  59                         {
  60                                 Atomic()
  61                                 { /* no-op */ }
  62
  63                                 explicit Atomic(T t)
  64                                         : rl::atomic< T >(t)
  65                                 { /* no-op */ }
  66
  67                                 template < typename D >
  68                                 T load(const D & debug_info, MemoryOrder memory_order = memory_order_seq_cst__) const
  69                                 {
  70                                         return rl::atomic< T >::load((rl::memory_order)memory_order, debug_info);
  71                                 }
  72
  73                                 template < typename D >
  74                                 void store(const D & debug_info, T value, MemoryOrder memory_order = memory_order_seq_cst__)
  75                                 {
  76                                         return rl::atomic< T >::store(value, (rl::memory_order)memory_order, debug_info);
  77                                 }
  78
  79                                 template < typename D >
  80                                 T exchange(const D & debug_info, T value, MemoryOrder memory_order = memory_order_seq_cst__)
  81                                 {
  82                                         return rl::atomic< T >::exchange(value, (rl::memory_order)memory_order, debug_info);
  83                                 }
  84
  85                                 template < typename D >
  86                                 bool cas(const D & debug_info, T * expected, T desired, MemoryOrder order = memory_order_seq_cst__)
  87                                 {
  88                                         return rl::atomic< T >::compare_exchange_strong(*expected, desired, (rl::memory_order)order, debug_info);
  89                                 }
  90
  91                                 template < typename D >
  92                                 T fetchAndAdd(const D & debug_info, T value, MemoryOrder order = memory_order_seq_cst__)
  93                                 {
  94                                         return rl::atomic< T >::fetch_add(value, (rl::memory_order)order, debug_info);
  95                                 }
  96
  97                                 template < typename D >
  98                                 void add(const D & debug_info, T value, MemoryOrder order = memory_order_seq_cst__)
  99                                 {
 100                                         rl::atomic< T >::fetch_add(value, (rl::memory_order)order, debug_info);
 101                                 }
 102
 103                                 template < typename D >
 104                                 void sub(const D & debug_info, T value, MemoryOrder order = memory_order_seq_cst__)
 105                                 {
 106                                         rl::atomic< T >::fetch_sub(value, (rl::memory_order)order, debug_info);
 107                                 }
 108                         };
 109
 110                         template < typename D >
 111                         static void membarRelease(const D & debug_info)
 112                         {
 113                                 rl::atomic_thread_fence(rl::mo_release, debug_info);
 114                         }
 115
 116                         template < typename D >
 117                         static void membarAcquire(const D & debug_info)
 118                         {
 119                                 rl::atomic_thread_fence(rl::mo_acquire, debug_info);
 120                         }
 121
 122                         template < typename D >
 123                         static void assertion(const D & debug_info, bool assertion, const char * assertion_text)
 124                         {
 125                                 RL_ASSERT_IMPL(assertion, rl::test_result_user_assert_failed, assertion_text, debug_info);
 126                         }
 127                 };
 128         }
 129 }
 130
 131 #endif