ceph/src/boost/libs/atomic/include/boost/atomic/detail/ops_gcc_sparc.hpp

   1 /*
   2  * Distributed under the Boost Software License, Version 1.0.
   3  * (See accompanying file LICENSE_1_0.txt or copy at
   4  * http://www.boost.org/LICENSE_1_0.txt)
   5  *
   6  * Copyright (c) 2010 Helge Bahmann
   7  * Copyright (c) 2013 Tim Blechmann
   8  * Copyright (c) 2014 Andrey Semashev
   9  */
  10 /*!
  11  * \file   atomic/detail/ops_gcc_sparc.hpp
  12  *
  13  * This header contains implementation of the \c operations template.
  14  */
  15
  16 #ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_
  17 #define BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_
  18
  19 #include <boost/memory_order.hpp>
  20 #include <boost/atomic/detail/config.hpp>
  21 #include <boost/atomic/detail/storage_type.hpp>
  22 #include <boost/atomic/detail/operations_fwd.hpp>
  23 #include <boost/atomic/capabilities.hpp>
  24 #include <boost/atomic/detail/ops_cas_based.hpp>
  25 #include <boost/atomic/detail/ops_extending_cas_based.hpp>
  26
  27 #ifdef BOOST_HAS_PRAGMA_ONCE
  28 #pragma once
  29 #endif
  30
  31 namespace boost {
  32 namespace atomics {
  33 namespace detail {
  34
  35 struct gcc_sparc_cas_base
  36 {
  37     static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true;
  38
  39     static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT
  40     {
  41         if (order == memory_order_seq_cst)
  42             __asm__ __volatile__ ("membar #Sync" ::: "memory");
  43         else if ((order & memory_order_release) != 0)
  44             __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory");
  45     }
  46
  47     static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT
  48     {
  49         if (order == memory_order_seq_cst)
  50             __asm__ __volatile__ ("membar #Sync" ::: "memory");
  51         else if ((order & (memory_order_consume | memory_order_acquire)) != 0)
  52             __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory");
  53     }
  54
  55     static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
  56     {
  57         if (order == memory_order_seq_cst)
  58             __asm__ __volatile__ ("membar #Sync" ::: "memory");
  59     }
  60 };
  61
  62 template< bool Signed >
  63 struct gcc_sparc_cas32 :
  64     public gcc_sparc_cas_base
  65 {
  66     typedef typename make_storage_type< 4u, Signed >::type storage_type;
  67     typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type;
  68
  69     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
  70     {
  71         fence_before(order);
  72         storage = v;
  73         fence_after_store(order);
  74     }
  75
  76     static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
  77     {
  78         storage_type v = storage;
  79         fence_after(order);
  80         return v;
  81     }
  82
  83     static BOOST_FORCEINLINE bool compare_exchange_strong(
  84         storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
  85     {
  86         fence_before(success_order);
  87         storage_type previous = expected;
  88         __asm__ __volatile__
  89         (
  90             "cas [%1], %2, %0"
  91             : "+r" (desired)
  92             : "r" (&storage), "r" (previous)
  93             : "memory"
  94         );
  95         const bool success = (desired == previous);
  96         if (success)
  97             fence_after(success_order);
  98         else
  99             fence_after(failure_order);
 100         expected = desired;
 101         return success;
 102     }
 103
 104     static BOOST_FORCEINLINE bool compare_exchange_weak(
 105         storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
 106     {
 107         return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
 108     }
 109
 110     static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
 111     {
 112         fence_before(order);
 113         __asm__ __volatile__
 114         (
 115             "swap [%1], %0"
 116             : "+r" (v)
 117             : "r" (&storage)
 118             : "memory"
 119         );
 120         fence_after(order);
 121         return v;
 122     }
 123
 124     static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
 125     {
 126         return true;
 127     }
 128 };
 129
 130 template< bool Signed >
 131 struct operations< 4u, Signed > :
 132     public cas_based_operations< gcc_sparc_cas32< Signed > >
 133 {
 134 };
 135
 136 template< bool Signed >
 137 struct operations< 1u, Signed > :
 138     public extending_cas_based_operations< operations< 4u, Signed >, 1u, Signed >
 139 {
 140 };
 141
 142 template< bool Signed >
 143 struct operations< 2u, Signed > :
 144     public extending_cas_based_operations< operations< 4u, Signed >, 2u, Signed >
 145 {
 146 };
 147
 148 template< bool Signed >
 149 struct gcc_sparc_cas64 :
 150     public gcc_sparc_cas_base
 151 {
 152     typedef typename make_storage_type< 8u, Signed >::type storage_type;
 153     typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type;
 154
 155     static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
 156     {
 157         fence_before(order);
 158         storage = v;
 159         fence_after_store(order);
 160     }
 161
 162     static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
 163     {
 164         storage_type v = storage;
 165         fence_after(order);
 166         return v;
 167     }
 168
 169     static BOOST_FORCEINLINE bool compare_exchange_strong(
 170         storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
 171     {
 172         fence_before(success_order);
 173         storage_type previous = expected;
 174         __asm__ __volatile__
 175         (
 176             "casx [%1], %2, %0"
 177             : "+r" (desired)
 178             : "r" (&storage), "r" (previous)
 179             : "memory"
 180         );
 181         const bool success = (desired == previous);
 182         if (success)
 183             fence_after(success_order);
 184         else
 185             fence_after(failure_order);
 186         expected = desired;
 187         return success;
 188     }
 189
 190     static BOOST_FORCEINLINE bool compare_exchange_weak(
 191         storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
 192     {
 193         return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
 194     }
 195
 196     static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
 197     {
 198         return true;
 199     }
 200 };
 201
 202 template< bool Signed >
 203 struct operations< 8u, Signed > :
 204     public cas_based_operations< cas_based_exchange< gcc_sparc_cas64< Signed > > >
 205 {
 206 };
 207
 208
 209 BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
 210 {
 211     switch (order)
 212     {
 213     case memory_order_release:
 214         __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory");
 215         break;
 216     case memory_order_consume:
 217     case memory_order_acquire:
 218         __asm__ __volatile__ ("membar #LoadLoad | #LoadStore" ::: "memory");
 219         break;
 220     case memory_order_acq_rel:
 221         __asm__ __volatile__ ("membar #LoadLoad | #LoadStore | #StoreStore" ::: "memory");
 222         break;
 223     case memory_order_seq_cst:
 224         __asm__ __volatile__ ("membar #Sync" ::: "memory");
 225         break;
 226     case memory_order_relaxed:
 227     default:
 228         break;
 229     }
 230 }
 231
 232 BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
 233 {
 234     if (order != memory_order_relaxed)
 235         __asm__ __volatile__ ("" ::: "memory");
 236 }
 237
 238 } // namespace detail
 239 } // namespace atomics
 240 } // namespace boost
 241
 242 #endif // BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_