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