Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hotspot/src/os_cpu/linux_x86/vm/orderAccess_linux_x86.inline.hpp
changeset 27632 39084a677e72
parent 25715 d5a8dbdc5150
child 29456 cc1c5203e60d
equal deleted inserted replaced
27631:43e4ac8bc726 27632:39084a677e72 
    29 #include "runtime/orderAccess.hpp"
 
    29 #include "runtime/orderAccess.hpp"
 
    30 #include "runtime/os.hpp"
 
    30 #include "runtime/os.hpp"
 
    31 
    31 
    32 // Implementation of class OrderAccess.
 
    32 // Implementation of class OrderAccess.
 
    33 
    33 
       
    34 // A compiler barrier, forcing the C++ compiler to invalidate all memory assumptions
 
       
    35 static inline void compiler_barrier() {
 
       
    36   __asm__ volatile ("" : : : "memory");
 
       
    37 }
 
       
    38 
    34 inline void OrderAccess::loadload()   { acquire(); }
 
    39 inline void OrderAccess::loadload()   { acquire(); }
 
    35 inline void OrderAccess::storestore() { release(); }
 
    40 inline void OrderAccess::storestore() { release(); }
 
    36 inline void OrderAccess::loadstore()  { acquire(); }
 
    41 inline void OrderAccess::loadstore()  { acquire(); }
 
    37 inline void OrderAccess::storeload()  { fence(); }
 
    42 inline void OrderAccess::storeload()  { fence(); }
 
    38 
    43 
    44   __asm__ volatile ("movl 0(%%esp),%0" : "=r" (local_dummy) : : "memory");
 
    49   __asm__ volatile ("movl 0(%%esp),%0" : "=r" (local_dummy) : : "memory");
 
    45 #endif // AMD64
 
    50 #endif // AMD64
 
    46 }
 
    51 }
 
    47 
    52 
    48 inline void OrderAccess::release() {
 
    53 inline void OrderAccess::release() {
 
    49   // Avoid hitting the same cache-line from
 
    54   compiler_barrier();
 
    50   // different threads.
 
       
    51   volatile jint local_dummy = 0;
 
       
    52 }
 
    55 }
 
    53 
    56 
    54 inline void OrderAccess::fence() {
 
    57 inline void OrderAccess::fence() {
 
    55   if (os::is_MP()) {
 
    58   if (os::is_MP()) {
 
    56     // always use locked addl since mfence is sometimes expensive
 
    59     // always use locked addl since mfence is sometimes expensive
 
    60     __asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", "memory");
 
    63     __asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", "memory");
 
    61 #endif
 
    64 #endif
 
    62   }
 
    65   }
 
    63 }
 
    66 }
 
    64 
    67 
    65 inline jbyte    OrderAccess::load_acquire(volatile jbyte*   p) { return *p; }
 
    68 inline jbyte    OrderAccess::load_acquire(volatile jbyte*   p) { jbyte   v = *p; compiler_barrier(); return v; }
 
    66 inline jshort   OrderAccess::load_acquire(volatile jshort*  p) { return *p; }
 
    69 inline jshort   OrderAccess::load_acquire(volatile jshort*  p) { jshort  v = *p; compiler_barrier(); return v; }
 
    67 inline jint     OrderAccess::load_acquire(volatile jint*    p) { return *p; }
 
    70 inline jint     OrderAccess::load_acquire(volatile jint*    p) { jint    v = *p; compiler_barrier(); return v; }
 
    68 inline jlong    OrderAccess::load_acquire(volatile jlong*   p) { return Atomic::load(p); }
 
    71 inline jlong    OrderAccess::load_acquire(volatile jlong*   p) { jlong   v = Atomic::load(p); compiler_barrier(); return v; }
 
    69 inline jubyte   OrderAccess::load_acquire(volatile jubyte*  p) { return *p; }
 
    72 inline jubyte   OrderAccess::load_acquire(volatile jubyte*  p) { jubyte  v = *p; compiler_barrier(); return v; }
 
    70 inline jushort  OrderAccess::load_acquire(volatile jushort* p) { return *p; }
 
    73 inline jushort  OrderAccess::load_acquire(volatile jushort* p) { jushort v = *p; compiler_barrier(); return v; }
 
    71 inline juint    OrderAccess::load_acquire(volatile juint*   p) { return *p; }
 
    74 inline juint    OrderAccess::load_acquire(volatile juint*   p) { juint   v = *p; compiler_barrier(); return v; }
 
    72 inline julong   OrderAccess::load_acquire(volatile julong*  p) { return Atomic::load((volatile jlong*)p); }
 
    75 inline julong   OrderAccess::load_acquire(volatile julong*  p) { julong  v = Atomic::load((volatile jlong*)p); compiler_barrier(); return v; }
 
    73 inline jfloat   OrderAccess::load_acquire(volatile jfloat*  p) { return *p; }
 
    76 inline jfloat   OrderAccess::load_acquire(volatile jfloat*  p) { jfloat  v = *p; compiler_barrier(); return v; }
 
    74 inline jdouble  OrderAccess::load_acquire(volatile jdouble* p) { return jdouble_cast(Atomic::load((volatile jlong*)p)); }
 
    77 inline jdouble  OrderAccess::load_acquire(volatile jdouble* p) { jdouble v = jdouble_cast(Atomic::load((volatile jlong*)p)); compiler_barrier(); return v; }
 
    75 
    78 
    76 inline intptr_t OrderAccess::load_ptr_acquire(volatile intptr_t*   p) { return *p; }
 
    79 inline intptr_t OrderAccess::load_ptr_acquire(volatile intptr_t*   p) { intptr_t v = *p; compiler_barrier(); return v; }
 
    77 inline void*    OrderAccess::load_ptr_acquire(volatile void*       p) { return *(void* volatile *)p; }
 
    80 inline void*    OrderAccess::load_ptr_acquire(volatile void*       p) { void*    v = *(void* volatile *)p; compiler_barrier(); return v; }
 
    78 inline void*    OrderAccess::load_ptr_acquire(const volatile void* p) { return *(void* const volatile *)p; }
 
    81 inline void*    OrderAccess::load_ptr_acquire(const volatile void* p) { void*    v = *(void* const volatile *)p; compiler_barrier(); return v; }
 
    79 
    82 
    80 inline void     OrderAccess::release_store(volatile jbyte*   p, jbyte   v) { *p = v; }
 
    83 inline void     OrderAccess::release_store(volatile jbyte*   p, jbyte   v) { compiler_barrier(); *p = v; }
 
    81 inline void     OrderAccess::release_store(volatile jshort*  p, jshort  v) { *p = v; }
 
    84 inline void     OrderAccess::release_store(volatile jshort*  p, jshort  v) { compiler_barrier(); *p = v; }
 
    82 inline void     OrderAccess::release_store(volatile jint*    p, jint    v) { *p = v; }
 
    85 inline void     OrderAccess::release_store(volatile jint*    p, jint    v) { compiler_barrier(); *p = v; }
 
    83 inline void     OrderAccess::release_store(volatile jlong*   p, jlong   v) { Atomic::store(v, p); }
 
    86 inline void     OrderAccess::release_store(volatile jlong*   p, jlong   v) { compiler_barrier(); Atomic::store(v, p); }
 
    84 inline void     OrderAccess::release_store(volatile jubyte*  p, jubyte  v) { *p = v; }
 
    87 inline void     OrderAccess::release_store(volatile jubyte*  p, jubyte  v) { compiler_barrier(); *p = v; }
 
    85 inline void     OrderAccess::release_store(volatile jushort* p, jushort v) { *p = v; }
 
    88 inline void     OrderAccess::release_store(volatile jushort* p, jushort v) { compiler_barrier(); *p = v; }
 
    86 inline void     OrderAccess::release_store(volatile juint*   p, juint   v) { *p = v; }
 
    89 inline void     OrderAccess::release_store(volatile juint*   p, juint   v) { compiler_barrier(); *p = v; }
 
    87 inline void     OrderAccess::release_store(volatile julong*  p, julong  v) { Atomic::store((jlong)v, (volatile jlong*)p); }
 
    90 inline void     OrderAccess::release_store(volatile julong*  p, julong  v) { compiler_barrier(); Atomic::store((jlong)v, (volatile jlong*)p); }
 
    88 inline void     OrderAccess::release_store(volatile jfloat*  p, jfloat  v) { *p = v; }
 
    91 inline void     OrderAccess::release_store(volatile jfloat*  p, jfloat  v) { compiler_barrier(); *p = v; }
 
    89 inline void     OrderAccess::release_store(volatile jdouble* p, jdouble v) { release_store((volatile jlong *)p, jlong_cast(v)); }
 
    92 inline void     OrderAccess::release_store(volatile jdouble* p, jdouble v) { release_store((volatile jlong *)p, jlong_cast(v)); }
 
    90 
    93 
    91 inline void     OrderAccess::release_store_ptr(volatile intptr_t* p, intptr_t v) { *p = v; }
 
    94 inline void     OrderAccess::release_store_ptr(volatile intptr_t* p, intptr_t v) { compiler_barrier(); *p = v; }
 
    92 inline void     OrderAccess::release_store_ptr(volatile void*     p, void*    v) { *(void* volatile *)p = v; }
 
    95 inline void     OrderAccess::release_store_ptr(volatile void*     p, void*    v) { compiler_barrier(); *(void* volatile *)p = v; }
 
    93 
    96 
    94 inline void     OrderAccess::store_fence(jbyte*  p, jbyte  v) {
 
    97 inline void     OrderAccess::store_fence(jbyte*  p, jbyte  v) {
 
    95   __asm__ volatile (  "xchgb (%2),%0"
 
    98   __asm__ volatile (  "xchgb (%2),%0"
 
    96                     : "=q" (v)
 
    99                     : "=q" (v)
 
    97                     : "0" (v), "r" (p)
 
   100                     : "0" (v), "r" (p)
jdk-sandbox