Mercurial > hg > truffle
annotate src/os_cpu/solaris_x86/vm/orderAccess_solaris_x86.inline.hpp @ 795:215f81b4d9b3
6841831: G1: assert(contains_reference(from),"We just added it!") fires
Summary: During parallel rset updating we have to make sure that the worker ids of the refinement threads do not intersect with the worker ids that can be claimed by the mutator threads.
Reviewed-by: tonyp
| author | iveresov |
|---|---|
| date | Mon, 18 May 2009 11:52:46 -0700 |
| parents | d0994e5bebce |
| children | bd02caa94611 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 * Copyright 2003-2007 Sun Microsystems, Inc. All Rights Reserved. | |
| 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 // Implementation of class OrderAccess. | |
| 26 | |
| 27 // For Sun Studio - implementation is in solaris_i486.il. | |
| 28 // For gcc - implementation is just below. | |
| 29 extern "C" void _OrderAccess_acquire(); | |
| 30 extern "C" void _OrderAccess_fence(); | |
| 31 | |
| 32 inline void OrderAccess::loadload() { acquire(); } | |
| 33 inline void OrderAccess::storestore() { release(); } | |
| 34 inline void OrderAccess::loadstore() { acquire(); } | |
| 35 inline void OrderAccess::storeload() { fence(); } | |
| 36 | |
| 37 inline void OrderAccess::acquire() { | |
| 38 _OrderAccess_acquire(); | |
| 39 | |
| 40 } | |
| 41 | |
| 42 inline void OrderAccess::release() { | |
| 43 dummy = 0; | |
| 44 } | |
| 45 | |
| 46 inline void OrderAccess::fence() { | |
| 47 if (os::is_MP()) { | |
| 48 _OrderAccess_fence(); | |
| 49 } | |
| 50 } | |
| 51 | |
| 52 #ifdef _GNU_SOURCE | |
| 53 | |
| 54 extern "C" { | |
| 55 inline void _OrderAccess_acquire() { | |
| 56 volatile intptr_t dummy; | |
| 57 #ifdef AMD64 | |
| 58 __asm__ volatile ("movq 0(%%rsp), %0" : "=r" (dummy) : : "memory"); | |
| 59 #else | |
| 60 __asm__ volatile ("movl 0(%%esp),%0" : "=r" (dummy) : : "memory"); | |
| 61 #endif // AMD64 | |
| 62 } | |
| 63 inline void _OrderAccess_fence() { | |
|
671
d0994e5bebce
6822204: volatile fences should prefer lock:addl to actual mfence instructions
never
parents:
0
diff
changeset
|
64 // Always use locked addl since mfence is sometimes expensive |
| 0 | 65 __asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", "memory"); |
| 66 } | |
| 67 | |
| 68 } | |
| 69 | |
| 70 #endif // GNU_SOURCE | |
| 71 | |
| 72 inline jbyte OrderAccess::load_acquire(volatile jbyte* p) { return *p; } | |
| 73 inline jshort OrderAccess::load_acquire(volatile jshort* p) { return *p; } | |
| 74 inline jint OrderAccess::load_acquire(volatile jint* p) { return *p; } | |
| 75 inline jlong OrderAccess::load_acquire(volatile jlong* p) { return *p; } | |
| 76 inline jubyte OrderAccess::load_acquire(volatile jubyte* p) { return *p; } | |
| 77 inline jushort OrderAccess::load_acquire(volatile jushort* p) { return *p; } | |
| 78 inline juint OrderAccess::load_acquire(volatile juint* p) { return *p; } | |
| 79 inline julong OrderAccess::load_acquire(volatile julong* p) { return *p; } | |
| 80 inline jfloat OrderAccess::load_acquire(volatile jfloat* p) { return *p; } | |
| 81 inline jdouble OrderAccess::load_acquire(volatile jdouble* p) { return *p; } | |
| 82 | |
| 83 inline intptr_t OrderAccess::load_ptr_acquire(volatile intptr_t* p) { return *p; } | |
| 84 inline void* OrderAccess::load_ptr_acquire(volatile void* p) { return *(void* volatile *)p; } | |
| 85 inline void* OrderAccess::load_ptr_acquire(const volatile void* p) { return *(void* const volatile *)p; } | |
| 86 | |
| 87 inline void OrderAccess::release_store(volatile jbyte* p, jbyte v) { *p = v; } | |
| 88 inline void OrderAccess::release_store(volatile jshort* p, jshort v) { *p = v; } | |
| 89 inline void OrderAccess::release_store(volatile jint* p, jint v) { *p = v; } | |
| 90 inline void OrderAccess::release_store(volatile jlong* p, jlong v) { *p = v; } | |
| 91 inline void OrderAccess::release_store(volatile jubyte* p, jubyte v) { *p = v; } | |
| 92 inline void OrderAccess::release_store(volatile jushort* p, jushort v) { *p = v; } | |
| 93 inline void OrderAccess::release_store(volatile juint* p, juint v) { *p = v; } | |
| 94 inline void OrderAccess::release_store(volatile julong* p, julong v) { *p = v; } | |
| 95 inline void OrderAccess::release_store(volatile jfloat* p, jfloat v) { *p = v; } | |
| 96 inline void OrderAccess::release_store(volatile jdouble* p, jdouble v) { *p = v; } | |
| 97 | |
| 98 inline void OrderAccess::release_store_ptr(volatile intptr_t* p, intptr_t v) { *p = v; } | |
| 99 inline void OrderAccess::release_store_ptr(volatile void* p, void* v) { *(void* volatile *)p = v; } | |
| 100 | |
| 101 inline void OrderAccess::store_fence(jbyte* p, jbyte v) { *p = v; fence(); } | |
| 102 inline void OrderAccess::store_fence(jshort* p, jshort v) { *p = v; fence(); } | |
| 103 inline void OrderAccess::store_fence(jint* p, jint v) { *p = v; fence(); } | |
| 104 inline void OrderAccess::store_fence(jlong* p, jlong v) { *p = v; fence(); } | |
| 105 inline void OrderAccess::store_fence(jubyte* p, jubyte v) { *p = v; fence(); } | |
| 106 inline void OrderAccess::store_fence(jushort* p, jushort v) { *p = v; fence(); } | |
| 107 inline void OrderAccess::store_fence(juint* p, juint v) { *p = v; fence(); } | |
| 108 inline void OrderAccess::store_fence(julong* p, julong v) { *p = v; fence(); } | |
| 109 inline void OrderAccess::store_fence(jfloat* p, jfloat v) { *p = v; fence(); } | |
| 110 inline void OrderAccess::store_fence(jdouble* p, jdouble v) { *p = v; fence(); } | |
| 111 | |
| 112 inline void OrderAccess::store_ptr_fence(intptr_t* p, intptr_t v) { *p = v; fence(); } | |
| 113 inline void OrderAccess::store_ptr_fence(void** p, void* v) { *p = v; fence(); } | |
| 114 | |
| 115 inline void OrderAccess::release_store_fence(volatile jbyte* p, jbyte v) { *p = v; fence(); } | |
| 116 inline void OrderAccess::release_store_fence(volatile jshort* p, jshort v) { *p = v; fence(); } | |
| 117 inline void OrderAccess::release_store_fence(volatile jint* p, jint v) { *p = v; fence(); } | |
| 118 inline void OrderAccess::release_store_fence(volatile jlong* p, jlong v) { *p = v; fence(); } | |
| 119 inline void OrderAccess::release_store_fence(volatile jubyte* p, jubyte v) { *p = v; fence(); } | |
| 120 inline void OrderAccess::release_store_fence(volatile jushort* p, jushort v) { *p = v; fence(); } | |
| 121 inline void OrderAccess::release_store_fence(volatile juint* p, juint v) { *p = v; fence(); } | |
| 122 inline void OrderAccess::release_store_fence(volatile julong* p, julong v) { *p = v; fence(); } | |
| 123 inline void OrderAccess::release_store_fence(volatile jfloat* p, jfloat v) { *p = v; fence(); } | |
| 124 inline void OrderAccess::release_store_fence(volatile jdouble* p, jdouble v) { *p = v; fence(); } | |
| 125 | |
| 126 inline void OrderAccess::release_store_ptr_fence(volatile intptr_t* p, intptr_t v) { *p = v; fence(); } | |
| 127 inline void OrderAccess::release_store_ptr_fence(volatile void* p, void* v) { *(void* volatile *)p = v; fence(); } |