< prev index next >

src/hotspot/os_cpu/linux_zero/atomic_linux_zero.hpp

Print this page




  76   return result;
  77 }
  78 
  79 template<>
  80 template<typename T>
  81 inline T Atomic::PlatformXchg<8>::operator()(T volatile* dest,
  82                                              T exchange_value,
  83                                              atomic_memory_order order) const {
  84   STATIC_ASSERT(8 == sizeof(T));
  85   T result = __sync_lock_test_and_set (dest, exchange_value);
  86   __sync_synchronize();
  87   return result;
  88 }
  89 
  90 // No direct support for cmpxchg of bytes; emulate using int.
  91 template<>
  92 struct Atomic::PlatformCmpxchg<1> : Atomic::CmpxchgByteUsingInt {};
  93 
  94 template<>
  95 template<typename T>
  96 inline T Atomic::PlatformCmpxchg<4>::operator()(T exchange_value,
  97                                                 T volatile* dest,
  98                                                 T compare_value,

  99                                                 atomic_memory_order order) const {
 100   STATIC_ASSERT(4 == sizeof(T));
 101   return __sync_val_compare_and_swap(dest, compare_value, exchange_value);
 102 }
 103 
 104 template<>
 105 template<typename T>
 106 inline T Atomic::PlatformCmpxchg<8>::operator()(T exchange_value,
 107                                                 T volatile* dest,
 108                                                 T compare_value,

 109                                                 atomic_memory_order order) const {
 110   STATIC_ASSERT(8 == sizeof(T));
 111   return __sync_val_compare_and_swap(dest, compare_value, exchange_value);
 112 }
 113 
 114 template<>
 115 template<typename T>
 116 inline T Atomic::PlatformLoad<8>::operator()(T const volatile* src) const {
 117   STATIC_ASSERT(8 == sizeof(T));
 118   volatile int64_t dest;
 119   os::atomic_copy64(reinterpret_cast<const volatile int64_t*>(src), reinterpret_cast<volatile int64_t*>(&dest));
 120   return PrimitiveConversions::cast<T>(dest);
 121 }
 122 
 123 template<>
 124 template<typename T>
 125 inline void Atomic::PlatformStore<8>::operator()(T volatile* dest,
 126                                                  T store_value) const {
 127   STATIC_ASSERT(8 == sizeof(T));
 128   os::atomic_copy64(reinterpret_cast<const volatile int64_t*>(&store_value), reinterpret_cast<volatile int64_t*>(dest));


  76   return result;
  77 }
  78 
  79 template<>
  80 template<typename T>
  81 inline T Atomic::PlatformXchg<8>::operator()(T volatile* dest,
  82                                              T exchange_value,
  83                                              atomic_memory_order order) const {
  84   STATIC_ASSERT(8 == sizeof(T));
  85   T result = __sync_lock_test_and_set (dest, exchange_value);
  86   __sync_synchronize();
  87   return result;
  88 }
  89 
  90 // No direct support for cmpxchg of bytes; emulate using int.
  91 template<>
  92 struct Atomic::PlatformCmpxchg<1> : Atomic::CmpxchgByteUsingInt {};
  93 
  94 template<>
  95 template<typename T>
  96 inline T Atomic::PlatformCmpxchg<4>::operator()(T volatile* dest,

  97                                                 T compare_value,
  98                                                 T exchange_value,
  99                                                 atomic_memory_order order) const {
 100   STATIC_ASSERT(4 == sizeof(T));
 101   return __sync_val_compare_and_swap(dest, compare_value, exchange_value);
 102 }
 103 
 104 template<>
 105 template<typename T>
 106 inline T Atomic::PlatformCmpxchg<8>::operator()(T volatile* dest,

 107                                                 T compare_value,
 108                                                 T exchange_value,
 109                                                 atomic_memory_order order) const {
 110   STATIC_ASSERT(8 == sizeof(T));
 111   return __sync_val_compare_and_swap(dest, compare_value, exchange_value);
 112 }
 113 
 114 template<>
 115 template<typename T>
 116 inline T Atomic::PlatformLoad<8>::operator()(T const volatile* src) const {
 117   STATIC_ASSERT(8 == sizeof(T));
 118   volatile int64_t dest;
 119   os::atomic_copy64(reinterpret_cast<const volatile int64_t*>(src), reinterpret_cast<volatile int64_t*>(&dest));
 120   return PrimitiveConversions::cast<T>(dest);
 121 }
 122 
 123 template<>
 124 template<typename T>
 125 inline void Atomic::PlatformStore<8>::operator()(T volatile* dest,
 126                                                  T store_value) const {
 127   STATIC_ASSERT(8 == sizeof(T));
 128   os::atomic_copy64(reinterpret_cast<const volatile int64_t*>(&store_value), reinterpret_cast<volatile int64_t*>(dest));
< prev index next >