Mercurial > hg > truffle
annotate src/share/vm/oops/oop.inline.hpp @ 4710:41406797186b
7113012: G1: rename not-fully-young GCs as "mixed"
Summary: Renamed partially-young GCs as mixed and fully-young GCs as young. Change all external output that includes those terms (GC log and GC ergo log) as well as any comments, fields, methods, etc. The changeset also includes very minor code tidying up (added some curly brackets).
Reviewed-by: johnc, brutisso
| author | tonyp |
|---|---|
| date | Fri, 16 Dec 2011 02:14:27 -0500 |
| parents | b0efc7ee3b31 |
| children | 04b9a2566eec da91efe96a93 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
845
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
845
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
845
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_OOPS_OOP_INLINE_HPP |
| 26 #define SHARE_VM_OOPS_OOP_INLINE_HPP | |
| 27 | |
| 28 #include "gc_implementation/shared/ageTable.hpp" | |
| 29 #include "gc_implementation/shared/markSweep.inline.hpp" | |
| 30 #include "gc_interface/collectedHeap.inline.hpp" | |
| 31 #include "memory/barrierSet.inline.hpp" | |
| 32 #include "memory/cardTableModRefBS.hpp" | |
| 33 #include "memory/compactingPermGenGen.hpp" | |
| 34 #include "memory/genCollectedHeap.hpp" | |
| 35 #include "memory/generation.hpp" | |
| 36 #include "memory/permGen.hpp" | |
| 37 #include "memory/specialized_oop_closures.hpp" | |
| 38 #include "oops/arrayKlass.hpp" | |
| 39 #include "oops/arrayOop.hpp" | |
| 40 #include "oops/klass.hpp" | |
| 41 #include "oops/klassOop.hpp" | |
| 42 #include "oops/markOop.inline.hpp" | |
| 43 #include "oops/oop.hpp" | |
| 44 #include "runtime/atomic.hpp" | |
| 45 #include "runtime/os.hpp" | |
| 46 #ifdef TARGET_ARCH_x86 | |
| 47 # include "bytes_x86.hpp" | |
| 48 #endif | |
| 49 #ifdef TARGET_ARCH_sparc | |
| 50 # include "bytes_sparc.hpp" | |
| 51 #endif | |
| 52 #ifdef TARGET_ARCH_zero | |
| 53 # include "bytes_zero.hpp" | |
| 54 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
55 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
56 # include "bytes_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
57 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
58 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
59 # include "bytes_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
60 #endif |
| 1972 | 61 |
| 0 | 62 // Implementation of all inlined member functions defined in oop.hpp |
| 63 // We need a separate file to avoid circular references | |
| 64 | |
| 65 inline void oopDesc::release_set_mark(markOop m) { | |
| 66 OrderAccess::release_store_ptr(&_mark, m); | |
| 67 } | |
| 68 | |
| 69 inline markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) { | |
| 70 return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark); | |
| 71 } | |
| 72 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
73 inline klassOop oopDesc::klass() const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
74 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
75 return (klassOop)decode_heap_oop_not_null(_metadata._compressed_klass); |
|
167
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
76 } else { |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
77 return _metadata._klass; |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
78 } |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
79 } |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
80 |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
81 inline klassOop oopDesc::klass_or_null() const volatile { |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
82 // can be NULL in CMS |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
83 if (UseCompressedOops) { |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
84 return (klassOop)decode_heap_oop(_metadata._compressed_klass); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
85 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
86 return _metadata._klass; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
87 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
88 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
89 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
90 inline int oopDesc::klass_gap_offset_in_bytes() { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
91 assert(UseCompressedOops, "only applicable to compressed headers"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
92 return oopDesc::klass_offset_in_bytes() + sizeof(narrowOop); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
93 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
94 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
95 inline oop* oopDesc::klass_addr() { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
96 // Only used internally and with CMS and will not work with |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
97 // UseCompressedOops |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
98 assert(!UseCompressedOops, "only supported with uncompressed oops"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
99 return (oop*) &_metadata._klass; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
100 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
101 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
102 inline narrowOop* oopDesc::compressed_klass_addr() { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
103 assert(UseCompressedOops, "only called by compressed oops"); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
104 return (narrowOop*) &_metadata._compressed_klass; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
105 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
106 |
| 0 | 107 inline void oopDesc::set_klass(klassOop k) { |
| 108 // since klasses are promoted no store check is needed | |
| 109 assert(Universe::is_bootstrapping() || k != NULL, "must be a real klassOop"); | |
| 110 assert(Universe::is_bootstrapping() || k->is_klass(), "not a klassOop"); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
111 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
112 oop_store_without_check(compressed_klass_addr(), (oop)k); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
113 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
114 oop_store_without_check(klass_addr(), (oop) k); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
115 } |
| 0 | 116 } |
| 117 | |
|
167
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
118 inline int oopDesc::klass_gap() const { |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
119 return *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()); |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
120 } |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
121 |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
122 inline void oopDesc::set_klass_gap(int v) { |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
123 if (UseCompressedOops) { |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
124 *(int*)(((intptr_t)this) + klass_gap_offset_in_bytes()) = v; |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
125 } |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
126 } |
|
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
127 |
| 0 | 128 inline void oopDesc::set_klass_to_list_ptr(oop k) { |
| 129 // This is only to be used during GC, for from-space objects, so no | |
| 130 // barrier is needed. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
131 if (UseCompressedOops) { |
|
454
df4305d4c1a1
6774607: SIGSEGV or (!is_null(v),"oop value can never be zero") assertion when running with CMS and COOPs
ysr
parents:
356
diff
changeset
|
132 _metadata._compressed_klass = encode_heap_oop(k); // may be null (parnew overflow handling) |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
133 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
134 _metadata._klass = (klassOop)k; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
135 } |
| 0 | 136 } |
| 137 | |
| 138 inline void oopDesc::init_mark() { set_mark(markOopDesc::prototype_for_object(this)); } | |
| 139 inline Klass* oopDesc::blueprint() const { return klass()->klass_part(); } | |
| 140 | |
| 141 inline bool oopDesc::is_a(klassOop k) const { return blueprint()->is_subtype_of(k); } | |
| 142 | |
| 143 inline bool oopDesc::is_instance() const { return blueprint()->oop_is_instance(); } | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
144 inline bool oopDesc::is_instanceMirror() const { return blueprint()->oop_is_instanceMirror(); } |
| 0 | 145 inline bool oopDesc::is_instanceRef() const { return blueprint()->oop_is_instanceRef(); } |
| 146 inline bool oopDesc::is_array() const { return blueprint()->oop_is_array(); } | |
| 147 inline bool oopDesc::is_objArray() const { return blueprint()->oop_is_objArray(); } | |
| 148 inline bool oopDesc::is_typeArray() const { return blueprint()->oop_is_typeArray(); } | |
| 149 inline bool oopDesc::is_javaArray() const { return blueprint()->oop_is_javaArray(); } | |
| 150 inline bool oopDesc::is_klass() const { return blueprint()->oop_is_klass(); } | |
| 151 inline bool oopDesc::is_thread() const { return blueprint()->oop_is_thread(); } | |
| 152 inline bool oopDesc::is_method() const { return blueprint()->oop_is_method(); } | |
| 153 inline bool oopDesc::is_constMethod() const { return blueprint()->oop_is_constMethod(); } | |
| 154 inline bool oopDesc::is_methodData() const { return blueprint()->oop_is_methodData(); } | |
| 155 inline bool oopDesc::is_constantPool() const { return blueprint()->oop_is_constantPool(); } | |
| 156 inline bool oopDesc::is_constantPoolCache() const { return blueprint()->oop_is_constantPoolCache(); } | |
| 157 inline bool oopDesc::is_compiledICHolder() const { return blueprint()->oop_is_compiledICHolder(); } | |
| 158 | |
| 159 inline void* oopDesc::field_base(int offset) const { return (void*)&((char*)this)[offset]; } | |
| 160 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
161 template <class T> inline T* oopDesc::obj_field_addr(int offset) const { return (T*)field_base(offset); } |
| 0 | 162 inline jbyte* oopDesc::byte_field_addr(int offset) const { return (jbyte*) field_base(offset); } |
| 163 inline jchar* oopDesc::char_field_addr(int offset) const { return (jchar*) field_base(offset); } | |
| 164 inline jboolean* oopDesc::bool_field_addr(int offset) const { return (jboolean*)field_base(offset); } | |
| 165 inline jint* oopDesc::int_field_addr(int offset) const { return (jint*) field_base(offset); } | |
| 166 inline jshort* oopDesc::short_field_addr(int offset) const { return (jshort*) field_base(offset); } | |
| 167 inline jlong* oopDesc::long_field_addr(int offset) const { return (jlong*) field_base(offset); } | |
| 168 inline jfloat* oopDesc::float_field_addr(int offset) const { return (jfloat*) field_base(offset); } | |
| 169 inline jdouble* oopDesc::double_field_addr(int offset) const { return (jdouble*) field_base(offset); } | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
170 inline address* oopDesc::address_field_addr(int offset) const { return (address*) field_base(offset); } |
| 0 | 171 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
172 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
173 // Functions for getting and setting oops within instance objects. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
174 // If the oops are compressed, the type passed to these overloaded functions |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
175 // is narrowOop. All functions are overloaded so they can be called by |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
176 // template functions without conditionals (the compiler instantiates via |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
177 // the right type and inlines the appopriate code). |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
178 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
179 inline bool oopDesc::is_null(oop obj) { return obj == NULL; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
180 inline bool oopDesc::is_null(narrowOop obj) { return obj == 0; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
181 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
182 // Algorithm for encoding and decoding oops from 64 bit pointers to 32 bit |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
183 // offset from the heap base. Saving the check for null can save instructions |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
184 // in inner GC loops so these are separated. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
185 |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
186 inline bool check_obj_alignment(oop obj) { |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
187 return (intptr_t)obj % MinObjAlignmentInBytes == 0; |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
188 } |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
189 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
190 inline narrowOop oopDesc::encode_heap_oop_not_null(oop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
191 assert(!is_null(v), "oop value can never be zero"); |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
192 assert(check_obj_alignment(v), "Address not aligned"); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
710
diff
changeset
|
193 assert(Universe::heap()->is_in_reserved(v), "Address not in heap"); |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
518
diff
changeset
|
194 address base = Universe::narrow_oop_base(); |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
518
diff
changeset
|
195 int shift = Universe::narrow_oop_shift(); |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
518
diff
changeset
|
196 uint64_t pd = (uint64_t)(pointer_delta((void*)v, (void*)base, 1)); |
|
135
b7268662a986
6689523: max heap calculation for compressed oops is off by MaxPermSize
coleenp
parents:
133
diff
changeset
|
197 assert(OopEncodingHeapMax > pd, "change encoding max if new encoding"); |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
518
diff
changeset
|
198 uint64_t result = pd >> shift; |
|
135
b7268662a986
6689523: max heap calculation for compressed oops is off by MaxPermSize
coleenp
parents:
133
diff
changeset
|
199 assert((result & CONST64(0xffffffff00000000)) == 0, "narrow oop overflow"); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
710
diff
changeset
|
200 assert(decode_heap_oop(result) == v, "reversibility"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
201 return (narrowOop)result; |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
202 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
203 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
204 inline narrowOop oopDesc::encode_heap_oop(oop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
205 return (is_null(v)) ? (narrowOop)0 : encode_heap_oop_not_null(v); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
206 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
207 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
208 inline oop oopDesc::decode_heap_oop_not_null(narrowOop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
209 assert(!is_null(v), "narrow oop value can never be zero"); |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
518
diff
changeset
|
210 address base = Universe::narrow_oop_base(); |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
518
diff
changeset
|
211 int shift = Universe::narrow_oop_shift(); |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
212 oop result = (oop)(void*)((uintptr_t)base + ((uintptr_t)v << shift)); |
| 1846 | 213 assert(check_obj_alignment(result), err_msg("address not aligned: " PTR_FORMAT, (void*) result)); |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
214 return result; |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
215 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
216 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
217 inline oop oopDesc::decode_heap_oop(narrowOop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
218 return is_null(v) ? (oop)NULL : decode_heap_oop_not_null(v); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
219 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
220 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
221 inline oop oopDesc::decode_heap_oop_not_null(oop v) { return v; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
222 inline oop oopDesc::decode_heap_oop(oop v) { return v; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
223 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
224 // Load an oop out of the Java heap as is without decoding. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
225 // Called by GC to check for null before decoding. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
226 inline oop oopDesc::load_heap_oop(oop* p) { return *p; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
227 inline narrowOop oopDesc::load_heap_oop(narrowOop* p) { return *p; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
228 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
229 // Load and decode an oop out of the Java heap into a wide oop. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
230 inline oop oopDesc::load_decode_heap_oop_not_null(oop* p) { return *p; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
231 inline oop oopDesc::load_decode_heap_oop_not_null(narrowOop* p) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
232 return decode_heap_oop_not_null(*p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
233 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
234 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
235 // Load and decode an oop out of the heap accepting null |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
236 inline oop oopDesc::load_decode_heap_oop(oop* p) { return *p; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
237 inline oop oopDesc::load_decode_heap_oop(narrowOop* p) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
238 return decode_heap_oop(*p); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
239 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
240 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
241 // Store already encoded heap oop into the heap. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
242 inline void oopDesc::store_heap_oop(oop* p, oop v) { *p = v; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
243 inline void oopDesc::store_heap_oop(narrowOop* p, narrowOop v) { *p = v; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
244 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
245 // Encode and store a heap oop. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
246 inline void oopDesc::encode_store_heap_oop_not_null(narrowOop* p, oop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
247 *p = encode_heap_oop_not_null(v); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
248 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
249 inline void oopDesc::encode_store_heap_oop_not_null(oop* p, oop v) { *p = v; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
250 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
251 // Encode and store a heap oop allowing for null. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
252 inline void oopDesc::encode_store_heap_oop(narrowOop* p, oop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
253 *p = encode_heap_oop(v); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
254 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
255 inline void oopDesc::encode_store_heap_oop(oop* p, oop v) { *p = v; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
256 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
257 // Store heap oop as is for volatile fields. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
258 inline void oopDesc::release_store_heap_oop(volatile oop* p, oop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
259 OrderAccess::release_store_ptr(p, v); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
260 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
261 inline void oopDesc::release_store_heap_oop(volatile narrowOop* p, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
262 narrowOop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
263 OrderAccess::release_store(p, v); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
264 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
265 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
266 inline void oopDesc::release_encode_store_heap_oop_not_null( |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
267 volatile narrowOop* p, oop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
268 // heap oop is not pointer sized. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
269 OrderAccess::release_store(p, encode_heap_oop_not_null(v)); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
270 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
271 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
272 inline void oopDesc::release_encode_store_heap_oop_not_null( |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
273 volatile oop* p, oop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
274 OrderAccess::release_store_ptr(p, v); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
275 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
276 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
277 inline void oopDesc::release_encode_store_heap_oop(volatile oop* p, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
278 oop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
279 OrderAccess::release_store_ptr(p, v); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
280 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
281 inline void oopDesc::release_encode_store_heap_oop( |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
282 volatile narrowOop* p, oop v) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
283 OrderAccess::release_store(p, encode_heap_oop(v)); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
284 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
285 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
286 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
287 // These functions are only used to exchange oop fields in instances, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
288 // not headers. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
289 inline oop oopDesc::atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
290 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
291 // encode exchange value from oop to T |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
292 narrowOop val = encode_heap_oop(exchange_value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
293 narrowOop old = (narrowOop)Atomic::xchg(val, (narrowOop*)dest); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
294 // decode old from T to oop |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
295 return decode_heap_oop(old); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
296 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
297 return (oop)Atomic::xchg_ptr(exchange_value, (oop*)dest); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
298 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
299 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
300 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
301 inline oop oopDesc::atomic_compare_exchange_oop(oop exchange_value, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
302 volatile HeapWord *dest, |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
303 oop compare_value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
304 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
305 // encode exchange and compare value from oop to T |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
306 narrowOop val = encode_heap_oop(exchange_value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
307 narrowOop cmp = encode_heap_oop(compare_value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
308 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
309 narrowOop old = (narrowOop) Atomic::cmpxchg(val, (narrowOop*)dest, cmp); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
310 // decode old from T to oop |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
311 return decode_heap_oop(old); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
312 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
313 return (oop)Atomic::cmpxchg_ptr(exchange_value, (oop*)dest, compare_value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
314 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
315 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
316 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
317 // In order to put or get a field out of an instance, must first check |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
318 // if the field has been compressed and uncompress it. |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
319 inline oop oopDesc::obj_field(int offset) const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
320 return UseCompressedOops ? |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
321 load_decode_heap_oop(obj_field_addr<narrowOop>(offset)) : |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
322 load_decode_heap_oop(obj_field_addr<oop>(offset)); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
323 } |
|
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
324 inline volatile oop oopDesc::obj_field_volatile(int offset) const { |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
325 volatile oop value = obj_field(offset); |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
326 OrderAccess::acquire(); |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
327 return value; |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
328 } |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
329 inline void oopDesc::obj_field_put(int offset, oop value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
330 UseCompressedOops ? oop_store(obj_field_addr<narrowOop>(offset), value) : |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
331 oop_store(obj_field_addr<oop>(offset), value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
332 } |
|
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
333 inline void oopDesc::obj_field_put_raw(int offset, oop value) { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
334 UseCompressedOops ? |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
335 encode_store_heap_oop(obj_field_addr<narrowOop>(offset), value) : |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
336 encode_store_heap_oop(obj_field_addr<oop>(offset), value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
337 } |
|
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
338 inline void oopDesc::obj_field_put_volatile(int offset, oop value) { |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
339 OrderAccess::release(); |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
340 obj_field_put(offset, value); |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
341 OrderAccess::fence(); |
|
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
342 } |
| 0 | 343 |
| 344 inline jbyte oopDesc::byte_field(int offset) const { return (jbyte) *byte_field_addr(offset); } | |
| 345 inline void oopDesc::byte_field_put(int offset, jbyte contents) { *byte_field_addr(offset) = (jint) contents; } | |
| 346 | |
| 347 inline jboolean oopDesc::bool_field(int offset) const { return (jboolean) *bool_field_addr(offset); } | |
| 348 inline void oopDesc::bool_field_put(int offset, jboolean contents) { *bool_field_addr(offset) = (jint) contents; } | |
| 349 | |
| 350 inline jchar oopDesc::char_field(int offset) const { return (jchar) *char_field_addr(offset); } | |
| 351 inline void oopDesc::char_field_put(int offset, jchar contents) { *char_field_addr(offset) = (jint) contents; } | |
| 352 | |
| 353 inline jint oopDesc::int_field(int offset) const { return *int_field_addr(offset); } | |
| 354 inline void oopDesc::int_field_put(int offset, jint contents) { *int_field_addr(offset) = contents; } | |
| 355 | |
| 356 inline jshort oopDesc::short_field(int offset) const { return (jshort) *short_field_addr(offset); } | |
| 357 inline void oopDesc::short_field_put(int offset, jshort contents) { *short_field_addr(offset) = (jint) contents;} | |
| 358 | |
| 359 inline jlong oopDesc::long_field(int offset) const { return *long_field_addr(offset); } | |
| 360 inline void oopDesc::long_field_put(int offset, jlong contents) { *long_field_addr(offset) = contents; } | |
| 361 | |
| 362 inline jfloat oopDesc::float_field(int offset) const { return *float_field_addr(offset); } | |
| 363 inline void oopDesc::float_field_put(int offset, jfloat contents) { *float_field_addr(offset) = contents; } | |
| 364 | |
| 365 inline jdouble oopDesc::double_field(int offset) const { return *double_field_addr(offset); } | |
| 366 inline void oopDesc::double_field_put(int offset, jdouble contents) { *double_field_addr(offset) = contents; } | |
| 367 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
368 inline address oopDesc::address_field(int offset) const { return *address_field_addr(offset); } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
369 inline void oopDesc::address_field_put(int offset, address contents) { *address_field_addr(offset) = contents; } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
370 |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
371 inline oop oopDesc::obj_field_acquire(int offset) const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
372 return UseCompressedOops ? |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
373 decode_heap_oop((narrowOop) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
374 OrderAccess::load_acquire(obj_field_addr<narrowOop>(offset))) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
375 : decode_heap_oop((oop) |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
376 OrderAccess::load_ptr_acquire(obj_field_addr<oop>(offset))); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
377 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
378 inline void oopDesc::release_obj_field_put(int offset, oop value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
379 UseCompressedOops ? |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
380 oop_store((volatile narrowOop*)obj_field_addr<narrowOop>(offset), value) : |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
381 oop_store((volatile oop*) obj_field_addr<oop>(offset), value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
382 } |
| 0 | 383 |
| 384 inline jbyte oopDesc::byte_field_acquire(int offset) const { return OrderAccess::load_acquire(byte_field_addr(offset)); } | |
| 385 inline void oopDesc::release_byte_field_put(int offset, jbyte contents) { OrderAccess::release_store(byte_field_addr(offset), contents); } | |
| 386 | |
| 387 inline jboolean oopDesc::bool_field_acquire(int offset) const { return OrderAccess::load_acquire(bool_field_addr(offset)); } | |
| 388 inline void oopDesc::release_bool_field_put(int offset, jboolean contents) { OrderAccess::release_store(bool_field_addr(offset), contents); } | |
| 389 | |
| 390 inline jchar oopDesc::char_field_acquire(int offset) const { return OrderAccess::load_acquire(char_field_addr(offset)); } | |
| 391 inline void oopDesc::release_char_field_put(int offset, jchar contents) { OrderAccess::release_store(char_field_addr(offset), contents); } | |
| 392 | |
| 393 inline jint oopDesc::int_field_acquire(int offset) const { return OrderAccess::load_acquire(int_field_addr(offset)); } | |
| 394 inline void oopDesc::release_int_field_put(int offset, jint contents) { OrderAccess::release_store(int_field_addr(offset), contents); } | |
| 395 | |
| 396 inline jshort oopDesc::short_field_acquire(int offset) const { return (jshort)OrderAccess::load_acquire(short_field_addr(offset)); } | |
| 397 inline void oopDesc::release_short_field_put(int offset, jshort contents) { OrderAccess::release_store(short_field_addr(offset), contents); } | |
| 398 | |
| 399 inline jlong oopDesc::long_field_acquire(int offset) const { return OrderAccess::load_acquire(long_field_addr(offset)); } | |
| 400 inline void oopDesc::release_long_field_put(int offset, jlong contents) { OrderAccess::release_store(long_field_addr(offset), contents); } | |
| 401 | |
| 402 inline jfloat oopDesc::float_field_acquire(int offset) const { return OrderAccess::load_acquire(float_field_addr(offset)); } | |
| 403 inline void oopDesc::release_float_field_put(int offset, jfloat contents) { OrderAccess::release_store(float_field_addr(offset), contents); } | |
| 404 | |
| 405 inline jdouble oopDesc::double_field_acquire(int offset) const { return OrderAccess::load_acquire(double_field_addr(offset)); } | |
| 406 inline void oopDesc::release_double_field_put(int offset, jdouble contents) { OrderAccess::release_store(double_field_addr(offset), contents); } | |
| 407 | |
| 710 | 408 inline address oopDesc::address_field_acquire(int offset) const { return (address) OrderAccess::load_ptr_acquire(address_field_addr(offset)); } |
| 409 inline void oopDesc::release_address_field_put(int offset, address contents) { OrderAccess::release_store_ptr(address_field_addr(offset), contents); } | |
| 410 | |
| 0 | 411 inline int oopDesc::size_given_klass(Klass* klass) { |
| 412 int lh = klass->layout_helper(); | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
413 int s; |
| 0 | 414 |
| 415 // lh is now a value computed at class initialization that may hint | |
| 416 // at the size. For instances, this is positive and equal to the | |
| 417 // size. For arrays, this is negative and provides log2 of the | |
| 418 // array element size. For other oops, it is zero and thus requires | |
| 419 // a virtual call. | |
| 420 // | |
| 421 // We go to all this trouble because the size computation is at the | |
| 422 // heart of phase 2 of mark-compaction, and called for every object, | |
| 423 // alive or dead. So the speed here is equal in importance to the | |
| 424 // speed of allocation. | |
| 425 | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
426 if (lh > Klass::_lh_neutral_value) { |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
427 if (!Klass::layout_helper_needs_slow_path(lh)) { |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
428 s = lh >> LogHeapWordSize; // deliver size scaled by wordSize |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
429 } else { |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
430 s = klass->oop_size(this); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
431 } |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
432 } else if (lh <= Klass::_lh_neutral_value) { |
| 0 | 433 // The most common case is instances; fall through if so. |
| 434 if (lh < Klass::_lh_neutral_value) { | |
| 435 // Second most common case is arrays. We have to fetch the | |
| 436 // length of the array, shift (multiply) it appropriately, | |
| 437 // up to wordSize, add the header, and align to object size. | |
| 438 size_t size_in_bytes; | |
| 439 #ifdef _M_IA64 | |
| 440 // The Windows Itanium Aug 2002 SDK hoists this load above | |
| 441 // the check for s < 0. An oop at the end of the heap will | |
| 442 // cause an access violation if this load is performed on a non | |
| 443 // array oop. Making the reference volatile prohibits this. | |
| 444 // (%%% please explain by what magic the length is actually fetched!) | |
| 445 volatile int *array_length; | |
| 446 array_length = (volatile int *)( (intptr_t)this + | |
| 447 arrayOopDesc::length_offset_in_bytes() ); | |
| 448 assert(array_length > 0, "Integer arithmetic problem somewhere"); | |
| 449 // Put into size_t to avoid overflow. | |
| 450 size_in_bytes = (size_t) array_length; | |
| 451 size_in_bytes = size_in_bytes << Klass::layout_helper_log2_element_size(lh); | |
| 452 #else | |
| 453 size_t array_length = (size_t) ((arrayOop)this)->length(); | |
| 454 size_in_bytes = array_length << Klass::layout_helper_log2_element_size(lh); | |
| 455 #endif | |
| 456 size_in_bytes += Klass::layout_helper_header_size(lh); | |
| 457 | |
| 458 // This code could be simplified, but by keeping array_header_in_bytes | |
| 459 // in units of bytes and doing it this way we can round up just once, | |
| 460 // skipping the intermediate round to HeapWordSize. Cast the result | |
| 461 // of round_to to size_t to guarantee unsigned division == right shift. | |
| 462 s = (int)((size_t)round_to(size_in_bytes, MinObjAlignmentInBytes) / | |
| 463 HeapWordSize); | |
| 464 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
465 // UseParNewGC, UseParallelGC and UseG1GC can change the length field |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
466 // of an "old copy" of an object array in the young gen so it indicates |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
467 // the grey portion of an already copied array. This will cause the first |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
468 // disjunct below to fail if the two comparands are computed across such |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
469 // a concurrent change. |
| 0 | 470 // UseParNewGC also runs with promotion labs (which look like int |
| 471 // filler arrays) which are subject to changing their declared size | |
| 472 // when finally retiring a PLAB; this also can cause the first disjunct | |
| 473 // to fail for another worker thread that is concurrently walking the block | |
| 474 // offset table. Both these invariant failures are benign for their | |
| 475 // current uses; we relax the assertion checking to cover these two cases below: | |
| 476 // is_objArray() && is_forwarded() // covers first scenario above | |
| 477 // || is_typeArray() // covers second scenario above | |
| 478 // If and when UseParallelGC uses the same obj array oop stealing/chunking | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
479 // technique, we will need to suitably modify the assertion. |
| 0 | 480 assert((s == klass->oop_size(this)) || |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
481 (Universe::heap()->is_gc_active() && |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
482 ((is_typeArray() && UseParNewGC) || |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
483 (is_objArray() && is_forwarded() && (UseParNewGC || UseParallelGC || UseG1GC)))), |
| 0 | 484 "wrong array object size"); |
| 485 } else { | |
| 486 // Must be zero, so bite the bullet and take the virtual call. | |
| 487 s = klass->oop_size(this); | |
| 488 } | |
| 489 } | |
| 490 | |
| 491 assert(s % MinObjAlignment == 0, "alignment check"); | |
| 492 assert(s > 0, "Bad size calculated"); | |
| 493 return s; | |
| 494 } | |
| 495 | |
| 496 | |
| 497 inline int oopDesc::size() { | |
| 498 return size_given_klass(blueprint()); | |
| 499 } | |
| 500 | |
| 501 inline bool oopDesc::is_parsable() { | |
| 502 return blueprint()->oop_is_parsable(this); | |
| 503 } | |
| 504 | |
|
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
454
diff
changeset
|
505 inline bool oopDesc::is_conc_safe() { |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
454
diff
changeset
|
506 return blueprint()->oop_is_conc_safe(this); |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
454
diff
changeset
|
507 } |
|
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
454
diff
changeset
|
508 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
509 inline void update_barrier_set(void* p, oop v) { |
| 0 | 510 assert(oopDesc::bs() != NULL, "Uninitialized bs in oop!"); |
| 511 oopDesc::bs()->write_ref_field(p, v); | |
| 512 } | |
| 513 | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
710
diff
changeset
|
514 template <class T> inline void update_barrier_set_pre(T* p, oop v) { |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
515 oopDesc::bs()->write_ref_field_pre(p, v); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
516 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
517 |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
518 template <class T> inline void oop_store(T* p, oop v) { |
| 0 | 519 if (always_do_update_barrier) { |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
520 oop_store((volatile T*)p, v); |
| 0 | 521 } else { |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
522 update_barrier_set_pre(p, v); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
523 oopDesc::encode_store_heap_oop(p, v); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
710
diff
changeset
|
524 update_barrier_set((void*)p, v); // cast away type |
| 0 | 525 } |
| 526 } | |
| 527 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
528 template <class T> inline void oop_store(volatile T* p, oop v) { |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
710
diff
changeset
|
529 update_barrier_set_pre((T*)p, v); // cast away volatile |
| 0 | 530 // Used by release_obj_field_put, so use release_store_ptr. |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
531 oopDesc::release_encode_store_heap_oop(p, v); |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
710
diff
changeset
|
532 update_barrier_set((void*)p, v); // cast away type |
| 0 | 533 } |
| 534 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
535 template <class T> inline void oop_store_without_check(T* p, oop v) { |
| 0 | 536 // XXX YSR FIX ME!!! |
| 537 if (always_do_update_barrier) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
538 oop_store(p, v); |
| 0 | 539 } else { |
| 540 assert(!Universe::heap()->barrier_set()->write_ref_needs_barrier(p, v), | |
| 541 "oop store without store check failed"); | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
542 oopDesc::encode_store_heap_oop(p, v); |
| 0 | 543 } |
| 544 } | |
| 545 | |
| 546 // When it absolutely has to get there. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
547 template <class T> inline void oop_store_without_check(volatile T* p, oop v) { |
| 0 | 548 // XXX YSR FIX ME!!! |
| 549 if (always_do_update_barrier) { | |
| 550 oop_store(p, v); | |
| 551 } else { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
552 assert(!Universe::heap()->barrier_set()->write_ref_needs_barrier((T*)p, v), |
| 0 | 553 "oop store without store check failed"); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
554 oopDesc::release_encode_store_heap_oop(p, v); |
| 0 | 555 } |
| 556 } | |
| 557 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
558 // Should replace *addr = oop assignments where addr type depends on UseCompressedOops |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
559 // (without having to remember the function name this calls). |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
560 inline void oop_store_raw(HeapWord* addr, oop value) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
561 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
562 oopDesc::encode_store_heap_oop((narrowOop*)addr, value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
563 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
564 oopDesc::encode_store_heap_oop((oop*)addr, value); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
565 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
566 } |
| 0 | 567 |
| 568 // Used only for markSweep, scavenging | |
| 569 inline bool oopDesc::is_gc_marked() const { | |
| 570 return mark()->is_marked(); | |
| 571 } | |
| 572 | |
| 573 inline bool oopDesc::is_locked() const { | |
| 574 return mark()->is_locked(); | |
| 575 } | |
| 576 | |
| 577 inline bool oopDesc::is_unlocked() const { | |
| 578 return mark()->is_unlocked(); | |
| 579 } | |
| 580 | |
| 581 inline bool oopDesc::has_bias_pattern() const { | |
| 582 return mark()->has_bias_pattern(); | |
| 583 } | |
| 584 | |
| 585 | |
| 586 // used only for asserts | |
| 587 inline bool oopDesc::is_oop(bool ignore_mark_word) const { | |
| 588 oop obj = (oop) this; | |
| 589 if (!check_obj_alignment(obj)) return false; | |
| 590 if (!Universe::heap()->is_in_reserved(obj)) return false; | |
| 591 // obj is aligned and accessible in heap | |
| 592 // try to find metaclass cycle safely without seg faulting on bad input | |
| 593 // we should reach klassKlassObj by following klass link at most 3 times | |
| 594 for (int i = 0; i < 3; i++) { | |
|
167
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
595 obj = obj->klass_or_null(); |
| 0 | 596 // klass should be aligned and in permspace |
| 597 if (!check_obj_alignment(obj)) return false; | |
| 598 if (!Universe::heap()->is_in_permanent(obj)) return false; | |
| 599 } | |
| 600 if (obj != Universe::klassKlassObj()) { | |
| 601 // During a dump, the _klassKlassObj moved to a shared space. | |
| 602 if (DumpSharedSpaces && Universe::klassKlassObj()->is_shared()) { | |
| 603 return true; | |
| 604 } | |
| 605 return false; | |
| 606 } | |
| 607 | |
| 608 // Header verification: the mark is typically non-NULL. If we're | |
| 609 // at a safepoint, it must not be null. | |
| 610 // Outside of a safepoint, the header could be changing (for example, | |
| 611 // another thread could be inflating a lock on this object). | |
| 612 if (ignore_mark_word) { | |
| 613 return true; | |
| 614 } | |
| 615 if (mark() != NULL) { | |
| 616 return true; | |
| 617 } | |
| 618 return !SafepointSynchronize::is_at_safepoint(); | |
| 619 } | |
| 620 | |
| 621 | |
| 622 // used only for asserts | |
| 623 inline bool oopDesc::is_oop_or_null(bool ignore_mark_word) const { | |
| 624 return this == NULL ? true : is_oop(ignore_mark_word); | |
| 625 } | |
| 626 | |
| 627 #ifndef PRODUCT | |
| 628 // used only for asserts | |
| 629 inline bool oopDesc::is_unlocked_oop() const { | |
| 630 if (!Universe::heap()->is_in_reserved(this)) return false; | |
| 631 return mark()->is_unlocked(); | |
| 632 } | |
| 633 #endif // PRODUCT | |
| 634 | |
| 635 inline void oopDesc::follow_header() { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
636 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
637 MarkSweep::mark_and_push(compressed_klass_addr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
638 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
639 MarkSweep::mark_and_push(klass_addr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
640 } |
| 0 | 641 } |
| 642 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
643 inline void oopDesc::follow_contents(void) { |
| 0 | 644 assert (is_gc_marked(), "should be marked"); |
| 645 blueprint()->oop_follow_contents(this); | |
| 646 } | |
| 647 | |
| 648 | |
| 649 // Used by scavengers | |
| 650 | |
| 651 inline bool oopDesc::is_forwarded() const { | |
| 652 // The extra heap check is needed since the obj might be locked, in which case the | |
| 653 // mark would point to a stack location and have the sentinel bit cleared | |
| 654 return mark()->is_marked(); | |
| 655 } | |
| 656 | |
| 657 // Used by scavengers | |
| 658 inline void oopDesc::forward_to(oop p) { | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
659 assert(check_obj_alignment(p), |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
660 "forwarding to something not aligned"); |
| 0 | 661 assert(Universe::heap()->is_in_reserved(p), |
| 662 "forwarding to something not in heap"); | |
| 663 markOop m = markOopDesc::encode_pointer_as_mark(p); | |
| 664 assert(m->decode_pointer() == p, "encoding must be reversable"); | |
| 665 set_mark(m); | |
| 666 } | |
| 667 | |
| 668 // Used by parallel scavengers | |
| 669 inline bool oopDesc::cas_forward_to(oop p, markOop compare) { | |
|
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
670 assert(check_obj_alignment(p), |
|
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
671 "forwarding to something not aligned"); |
| 0 | 672 assert(Universe::heap()->is_in_reserved(p), |
| 673 "forwarding to something not in heap"); | |
| 674 markOop m = markOopDesc::encode_pointer_as_mark(p); | |
| 675 assert(m->decode_pointer() == p, "encoding must be reversable"); | |
| 676 return cas_set_mark(m, compare) == compare; | |
| 677 } | |
| 678 | |
| 679 // Note that the forwardee is not the same thing as the displaced_mark. | |
| 680 // The forwardee is used when copying during scavenge and mark-sweep. | |
| 681 // It does need to clear the low two locking- and GC-related bits. | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
682 inline oop oopDesc::forwardee() const { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
683 return (oop) mark()->decode_pointer(); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
684 } |
| 0 | 685 |
| 686 inline bool oopDesc::has_displaced_mark() const { | |
| 687 return mark()->has_displaced_mark_helper(); | |
| 688 } | |
| 689 | |
| 690 inline markOop oopDesc::displaced_mark() const { | |
| 691 return mark()->displaced_mark_helper(); | |
| 692 } | |
| 693 | |
| 694 inline void oopDesc::set_displaced_mark(markOop m) { | |
| 695 mark()->set_displaced_mark_helper(m); | |
| 696 } | |
| 697 | |
| 698 // The following method needs to be MT safe. | |
| 699 inline int oopDesc::age() const { | |
| 700 assert(!is_forwarded(), "Attempt to read age from forwarded mark"); | |
| 701 if (has_displaced_mark()) { | |
| 702 return displaced_mark()->age(); | |
| 703 } else { | |
| 704 return mark()->age(); | |
| 705 } | |
| 706 } | |
| 707 | |
| 708 inline void oopDesc::incr_age() { | |
| 709 assert(!is_forwarded(), "Attempt to increment age of forwarded mark"); | |
| 710 if (has_displaced_mark()) { | |
| 711 set_displaced_mark(displaced_mark()->incr_age()); | |
| 712 } else { | |
| 713 set_mark(mark()->incr_age()); | |
| 714 } | |
| 715 } | |
| 716 | |
| 717 | |
| 718 inline intptr_t oopDesc::identity_hash() { | |
| 719 // Fast case; if the object is unlocked and the hash value is set, no locking is needed | |
| 720 // Note: The mark must be read into local variable to avoid concurrent updates. | |
| 721 markOop mrk = mark(); | |
| 722 if (mrk->is_unlocked() && !mrk->has_no_hash()) { | |
| 723 return mrk->hash(); | |
| 724 } else if (mrk->is_marked()) { | |
| 725 return mrk->hash(); | |
| 726 } else { | |
| 727 return slow_identity_hash(); | |
| 728 } | |
| 729 } | |
| 730 | |
| 731 inline void oopDesc::oop_iterate_header(OopClosure* blk) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
732 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
733 blk->do_oop(compressed_klass_addr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
734 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
735 blk->do_oop(klass_addr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
736 } |
| 0 | 737 } |
| 738 | |
| 739 inline void oopDesc::oop_iterate_header(OopClosure* blk, MemRegion mr) { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
740 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
741 if (mr.contains(compressed_klass_addr())) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
742 blk->do_oop(compressed_klass_addr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
743 } |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
744 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
745 if (mr.contains(klass_addr())) blk->do_oop(klass_addr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
746 } |
| 0 | 747 } |
| 748 | |
| 749 inline int oopDesc::adjust_pointers() { | |
| 750 debug_only(int check_size = size()); | |
| 751 int s = blueprint()->oop_adjust_pointers(this); | |
| 752 assert(s == check_size, "should be the same"); | |
| 753 return s; | |
| 754 } | |
| 755 | |
| 756 inline void oopDesc::adjust_header() { | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
757 if (UseCompressedOops) { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
758 MarkSweep::adjust_pointer(compressed_klass_addr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
759 } else { |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
760 MarkSweep::adjust_pointer(klass_addr()); |
|
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
761 } |
| 0 | 762 } |
| 763 | |
| 764 #define OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ | |
| 765 \ | |
| 766 inline int oopDesc::oop_iterate(OopClosureType* blk) { \ | |
| 767 SpecializationStats::record_call(); \ | |
| 768 return blueprint()->oop_oop_iterate##nv_suffix(this, blk); \ | |
| 769 } \ | |
| 770 \ | |
| 771 inline int oopDesc::oop_iterate(OopClosureType* blk, MemRegion mr) { \ | |
| 772 SpecializationStats::record_call(); \ | |
| 773 return blueprint()->oop_oop_iterate##nv_suffix##_m(this, blk, mr); \ | |
| 774 } | |
| 775 | |
| 776 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DEFN) | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
777 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DEFN) |
| 0 | 778 |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
779 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
780 #define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
781 \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
782 inline int oopDesc::oop_iterate_backwards(OopClosureType* blk) { \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
783 SpecializationStats::record_call(); \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
784 return blueprint()->oop_oop_iterate_backwards##nv_suffix(this, blk); \ |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
785 } |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
786 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
787 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DEFN) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
788 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DEFN) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
789 #endif // !SERIALGC |
| 0 | 790 |
| 791 inline bool oopDesc::is_shared() const { | |
| 792 return CompactingPermGenGen::is_shared(this); | |
| 793 } | |
| 794 | |
| 795 inline bool oopDesc::is_shared_readonly() const { | |
| 796 return CompactingPermGenGen::is_shared_readonly(this); | |
| 797 } | |
| 798 | |
| 799 inline bool oopDesc::is_shared_readwrite() const { | |
| 800 return CompactingPermGenGen::is_shared_readwrite(this); | |
| 801 } | |
| 1972 | 802 |
| 803 #endif // SHARE_VM_OOPS_OOP_INLINE_HPP |