Mercurial > hg > truffle
annotate src/share/vm/oops/oop.inline.hpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
author | Bernhard Urban <bernhard.urban@jku.at> |
---|---|
date | Mon, 15 Apr 2013 19:54:58 +0200 |
parents | 5fc51c1ecdeb |
children | 58fc8e2b7b6d |
rev | line source |
---|---|
0 | 1 /* |
7982
10d5f25a7c67
8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops
hseigel
parents:
6848
diff
changeset
|
2 * Copyright (c) 1997, 2013, 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/genCollectedHeap.hpp" | |
34 #include "memory/generation.hpp" | |
35 #include "memory/specialized_oop_closures.hpp" | |
36 #include "oops/arrayKlass.hpp" | |
37 #include "oops/arrayOop.hpp" | |
38 #include "oops/klass.hpp" | |
39 #include "oops/markOop.inline.hpp" | |
40 #include "oops/oop.hpp" | |
41 #include "runtime/atomic.hpp" | |
42 #include "runtime/os.hpp" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6848
diff
changeset
|
43 #include "utilities/macros.hpp" |
1972 | 44 #ifdef TARGET_ARCH_x86 |
45 # include "bytes_x86.hpp" | |
46 #endif | |
47 #ifdef TARGET_ARCH_sparc | |
48 # include "bytes_sparc.hpp" | |
49 #endif | |
50 #ifdef TARGET_ARCH_zero | |
51 # include "bytes_zero.hpp" | |
52 #endif | |
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
53 #ifdef TARGET_ARCH_arm |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
54 # include "bytes_arm.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
55 #endif |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
56 #ifdef TARGET_ARCH_ppc |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
57 # include "bytes_ppc.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
58 #endif |
1972 | 59 |
0 | 60 // Implementation of all inlined member functions defined in oop.hpp |
61 // We need a separate file to avoid circular references | |
62 | |
63 inline void oopDesc::release_set_mark(markOop m) { | |
64 OrderAccess::release_store_ptr(&_mark, m); | |
65 } | |
66 | |
67 inline markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) { | |
68 return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark); | |
69 } | |
70 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
71 inline Klass* oopDesc::klass() const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
72 if (UseCompressedKlassPointers) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
73 return decode_klass_not_null(_metadata._compressed_klass); |
167
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
74 } else { |
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
75 return _metadata._klass; |
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
76 } |
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
77 } |
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
78 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
79 inline Klass* oopDesc::klass_or_null() const volatile { |
167
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
80 // can be NULL in CMS |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
81 if (UseCompressedKlassPointers) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
82 return decode_klass(_metadata._compressed_klass); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
83 } else { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
84 return _metadata._klass; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
85 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
86 } |
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 inline int oopDesc::klass_gap_offset_in_bytes() { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
89 assert(UseCompressedKlassPointers, "only applicable to compressed klass pointers"); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
90 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
|
91 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
92 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
93 inline Klass** oopDesc::klass_addr() { |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
94 // 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
|
95 // UseCompressedOops |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
96 assert(!UseCompressedKlassPointers, "only supported with uncompressed klass pointers"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
97 return (Klass**) &_metadata._klass; |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
98 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
99 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
100 inline narrowOop* oopDesc::compressed_klass_addr() { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
101 assert(UseCompressedKlassPointers, "only called by compressed klass pointers"); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
102 return (narrowOop*) &_metadata._compressed_klass; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
103 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
104 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
105 inline void oopDesc::set_klass(Klass* k) { |
0 | 106 // since klasses are promoted no store check is needed |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
107 assert(Universe::is_bootstrapping() || k != NULL, "must be a real Klass*"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
108 assert(Universe::is_bootstrapping() || k->is_klass(), "not a Klass*"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
109 if (UseCompressedKlassPointers) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
110 *compressed_klass_addr() = encode_klass_not_null(k); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
111 } else { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
112 *klass_addr() = k; |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
113 } |
0 | 114 } |
115 | |
167
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
116 inline int oopDesc::klass_gap() const { |
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
117 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
|
118 } |
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
119 |
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
120 inline void oopDesc::set_klass_gap(int v) { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
121 if (UseCompressedKlassPointers) { |
167
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
122 *(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
|
123 } |
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
124 } |
feeb96a45707
6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC
coleenp
parents:
135
diff
changeset
|
125 |
0 | 126 inline void oopDesc::set_klass_to_list_ptr(oop k) { |
127 // This is only to be used during GC, for from-space objects, so no | |
128 // barrier is needed. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
129 if (UseCompressedKlassPointers) { |
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
|
130 _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
|
131 } else { |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
132 _metadata._klass = (Klass*)(address)k; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
133 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
134 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
135 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
136 inline oop oopDesc::list_ptr_from_klass() { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
137 // This is only to be used during GC, for from-space objects. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
138 if (UseCompressedKlassPointers) { |
6727
46c017102631
7195968: NPG: oopDesc::list_ptr_from_klass is broken
stefank
parents:
6725
diff
changeset
|
139 return decode_heap_oop(_metadata._compressed_klass); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
140 } else { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
141 // Special case for GC |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
142 return (oop)(address)_metadata._klass; |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
143 } |
0 | 144 } |
145 | |
146 inline void oopDesc::init_mark() { set_mark(markOopDesc::prototype_for_object(this)); } | |
147 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
148 inline bool oopDesc::is_a(Klass* k) const { return klass()->is_subtype_of(k); } |
0 | 149 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
150 inline bool oopDesc::is_instance() const { return klass()->oop_is_instance(); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
151 inline bool oopDesc::is_instanceMirror() const { return klass()->oop_is_instanceMirror(); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
152 inline bool oopDesc::is_instanceRef() const { return klass()->oop_is_instanceRef(); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
153 inline bool oopDesc::is_array() const { return klass()->oop_is_array(); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
154 inline bool oopDesc::is_objArray() const { return klass()->oop_is_objArray(); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
155 inline bool oopDesc::is_typeArray() const { return klass()->oop_is_typeArray(); } |
0 | 156 |
157 inline void* oopDesc::field_base(int offset) const { return (void*)&((char*)this)[offset]; } | |
158 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
159 template <class T> inline T* oopDesc::obj_field_addr(int offset) const { return (T*)field_base(offset); } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
160 inline Metadata** oopDesc::metadata_field_addr(int offset) const { return (Metadata**)field_base(offset); } |
0 | 161 inline jbyte* oopDesc::byte_field_addr(int offset) const { return (jbyte*) field_base(offset); } |
162 inline jchar* oopDesc::char_field_addr(int offset) const { return (jchar*) field_base(offset); } | |
163 inline jboolean* oopDesc::bool_field_addr(int offset) const { return (jboolean*)field_base(offset); } | |
164 inline jint* oopDesc::int_field_addr(int offset) const { return (jint*) field_base(offset); } | |
165 inline jshort* oopDesc::short_field_addr(int offset) const { return (jshort*) field_base(offset); } | |
166 inline jlong* oopDesc::long_field_addr(int offset) const { return (jlong*) field_base(offset); } | |
167 inline jfloat* oopDesc::float_field_addr(int offset) const { return (jfloat*) field_base(offset); } | |
168 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
|
169 inline address* oopDesc::address_field_addr(int offset) const { return (address*) field_base(offset); } |
0 | 170 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
171 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
172 // 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
|
173 // 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
|
174 // 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
|
175 // 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
|
176 // 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
|
177 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
178 inline bool oopDesc::is_null(oop obj) { return obj == NULL; } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
179 inline bool oopDesc::is_null(Klass* obj) { return obj == NULL; } |
113
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 } |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
189 inline bool check_klass_alignment(Klass* obj) { |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
190 return (intptr_t)obj % KlassAlignmentInBytes == 0; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
191 } |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
845
diff
changeset
|
192 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
193 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
|
194 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
|
195 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
|
196 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
|
197 address base = Universe::narrow_oop_base(); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
518
diff
changeset
|
198 int shift = Universe::narrow_oop_shift(); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
518
diff
changeset
|
199 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
|
200 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
|
201 uint64_t result = pd >> shift; |
135
b7268662a986
6689523: max heap calculation for compressed oops is off by MaxPermSize
coleenp
parents:
133
diff
changeset
|
202 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
|
203 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
|
204 return (narrowOop)result; |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
205 } |
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 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
|
208 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
|
209 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
210 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
211 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
|
212 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
|
213 address base = Universe::narrow_oop_base(); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
518
diff
changeset
|
214 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
|
215 oop result = (oop)(void*)((uintptr_t)base + ((uintptr_t)v << shift)); |
1846 | 216 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
|
217 return result; |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
218 } |
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 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
|
221 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
|
222 } |
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 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
|
225 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
|
226 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
227 // Encoding and decoding for klass field. It is copied code, but someday |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
228 // might not be the same as oop. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
229 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
230 inline narrowOop oopDesc::encode_klass_not_null(Klass* v) { |
7982
10d5f25a7c67
8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops
hseigel
parents:
6848
diff
changeset
|
231 assert(!is_null(v), "klass value can never be zero"); |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
232 assert(check_klass_alignment(v), "Address not aligned"); |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
233 address base = Universe::narrow_klass_base(); |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
234 int shift = Universe::narrow_klass_shift(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
235 uint64_t pd = (uint64_t)(pointer_delta((void*)v, (void*)base, 1)); |
7982
10d5f25a7c67
8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops
hseigel
parents:
6848
diff
changeset
|
236 assert(KlassEncodingMetaspaceMax > pd, "change encoding max if new encoding"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
237 uint64_t result = pd >> shift; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
238 assert((result & CONST64(0xffffffff00000000)) == 0, "narrow klass pointer overflow"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
239 assert(decode_klass(result) == v, "reversibility"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
240 return (narrowOop)result; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
241 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
242 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
243 inline narrowOop oopDesc::encode_klass(Klass* v) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
244 return (is_null(v)) ? (narrowOop)0 : encode_klass_not_null(v); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
245 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
246 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
247 inline Klass* oopDesc::decode_klass_not_null(narrowOop v) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
248 assert(!is_null(v), "narrow oop value can never be zero"); |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
249 address base = Universe::narrow_klass_base(); |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
250 int shift = Universe::narrow_klass_shift(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
251 Klass* result = (Klass*)(void*)((uintptr_t)base + ((uintptr_t)v << shift)); |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6818
diff
changeset
|
252 assert(check_klass_alignment(result), err_msg("address not aligned: " PTR_FORMAT, (void*) result)); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
253 return result; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
254 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
255 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
256 inline Klass* oopDesc::decode_klass(narrowOop v) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
257 return is_null(v) ? (Klass*)NULL : decode_klass_not_null(v); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
258 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
259 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
260 // 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
|
261 // 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
|
262 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
|
263 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
|
264 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
265 // 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
|
266 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
|
267 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
|
268 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
|
269 } |
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 // 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
|
272 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
|
273 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
|
274 return decode_heap_oop(*p); |
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 // 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
|
278 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
|
279 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
|
280 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
281 // 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
|
282 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
|
283 *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
|
284 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
285 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
|
286 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
287 // 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
|
288 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
|
289 *p = encode_heap_oop(v); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
290 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
291 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
|
292 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
293 // 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
|
294 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
|
295 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
|
296 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
297 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
|
298 narrowOop v) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
299 OrderAccess::release_store(p, v); |
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 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
302 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
|
303 volatile narrowOop* p, oop v) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
304 // 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
|
305 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
|
306 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
307 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
308 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
|
309 volatile oop* p, oop v) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
310 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
|
311 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
312 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
313 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
|
314 oop v) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
315 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
|
316 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
317 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
|
318 volatile narrowOop* p, oop v) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
319 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
|
320 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
321 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
322 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
323 // 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
|
324 // not headers. |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
325 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
|
326 if (UseCompressedOops) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
327 // 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
|
328 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
|
329 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
|
330 // 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
|
331 return decode_heap_oop(old); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
332 } else { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
333 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
|
334 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
335 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
336 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
337 // 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
|
338 // 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
|
339 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
|
340 return UseCompressedOops ? |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
341 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
|
342 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
|
343 } |
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
344 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
|
345 volatile oop value = obj_field(offset); |
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
346 OrderAccess::acquire(); |
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
347 return value; |
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
348 } |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
349 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
|
350 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
|
351 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
|
352 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
353 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
354 inline Metadata* oopDesc::metadata_field(int offset) const { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
355 return *metadata_field_addr(offset); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
356 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
357 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
358 inline void oopDesc::metadata_field_put(int offset, Metadata* value) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
359 *metadata_field_addr(offset) = value; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
360 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
361 |
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
362 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
|
363 UseCompressedOops ? |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
364 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
|
365 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
|
366 } |
3932
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
367 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
|
368 OrderAccess::release(); |
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
369 obj_field_put(offset, value); |
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
370 OrderAccess::fence(); |
b0efc7ee3b31
7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods
twisti
parents:
2376
diff
changeset
|
371 } |
0 | 372 |
373 inline jbyte oopDesc::byte_field(int offset) const { return (jbyte) *byte_field_addr(offset); } | |
374 inline void oopDesc::byte_field_put(int offset, jbyte contents) { *byte_field_addr(offset) = (jint) contents; } | |
375 | |
376 inline jboolean oopDesc::bool_field(int offset) const { return (jboolean) *bool_field_addr(offset); } | |
377 inline void oopDesc::bool_field_put(int offset, jboolean contents) { *bool_field_addr(offset) = (jint) contents; } | |
378 | |
379 inline jchar oopDesc::char_field(int offset) const { return (jchar) *char_field_addr(offset); } | |
380 inline void oopDesc::char_field_put(int offset, jchar contents) { *char_field_addr(offset) = (jint) contents; } | |
381 | |
382 inline jint oopDesc::int_field(int offset) const { return *int_field_addr(offset); } | |
383 inline void oopDesc::int_field_put(int offset, jint contents) { *int_field_addr(offset) = contents; } | |
384 | |
385 inline jshort oopDesc::short_field(int offset) const { return (jshort) *short_field_addr(offset); } | |
386 inline void oopDesc::short_field_put(int offset, jshort contents) { *short_field_addr(offset) = (jint) contents;} | |
387 | |
388 inline jlong oopDesc::long_field(int offset) const { return *long_field_addr(offset); } | |
389 inline void oopDesc::long_field_put(int offset, jlong contents) { *long_field_addr(offset) = contents; } | |
390 | |
391 inline jfloat oopDesc::float_field(int offset) const { return *float_field_addr(offset); } | |
392 inline void oopDesc::float_field_put(int offset, jfloat contents) { *float_field_addr(offset) = contents; } | |
393 | |
394 inline jdouble oopDesc::double_field(int offset) const { return *double_field_addr(offset); } | |
395 inline void oopDesc::double_field_put(int offset, jdouble contents) { *double_field_addr(offset) = contents; } | |
396 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
397 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
|
398 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
|
399 |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
400 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
|
401 return UseCompressedOops ? |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
402 decode_heap_oop((narrowOop) |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
403 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
|
404 : decode_heap_oop((oop) |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
405 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
|
406 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
407 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
|
408 UseCompressedOops ? |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
409 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
|
410 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
|
411 } |
0 | 412 |
413 inline jbyte oopDesc::byte_field_acquire(int offset) const { return OrderAccess::load_acquire(byte_field_addr(offset)); } | |
414 inline void oopDesc::release_byte_field_put(int offset, jbyte contents) { OrderAccess::release_store(byte_field_addr(offset), contents); } | |
415 | |
416 inline jboolean oopDesc::bool_field_acquire(int offset) const { return OrderAccess::load_acquire(bool_field_addr(offset)); } | |
417 inline void oopDesc::release_bool_field_put(int offset, jboolean contents) { OrderAccess::release_store(bool_field_addr(offset), contents); } | |
418 | |
419 inline jchar oopDesc::char_field_acquire(int offset) const { return OrderAccess::load_acquire(char_field_addr(offset)); } | |
420 inline void oopDesc::release_char_field_put(int offset, jchar contents) { OrderAccess::release_store(char_field_addr(offset), contents); } | |
421 | |
422 inline jint oopDesc::int_field_acquire(int offset) const { return OrderAccess::load_acquire(int_field_addr(offset)); } | |
423 inline void oopDesc::release_int_field_put(int offset, jint contents) { OrderAccess::release_store(int_field_addr(offset), contents); } | |
424 | |
425 inline jshort oopDesc::short_field_acquire(int offset) const { return (jshort)OrderAccess::load_acquire(short_field_addr(offset)); } | |
426 inline void oopDesc::release_short_field_put(int offset, jshort contents) { OrderAccess::release_store(short_field_addr(offset), contents); } | |
427 | |
428 inline jlong oopDesc::long_field_acquire(int offset) const { return OrderAccess::load_acquire(long_field_addr(offset)); } | |
429 inline void oopDesc::release_long_field_put(int offset, jlong contents) { OrderAccess::release_store(long_field_addr(offset), contents); } | |
430 | |
431 inline jfloat oopDesc::float_field_acquire(int offset) const { return OrderAccess::load_acquire(float_field_addr(offset)); } | |
432 inline void oopDesc::release_float_field_put(int offset, jfloat contents) { OrderAccess::release_store(float_field_addr(offset), contents); } | |
433 | |
434 inline jdouble oopDesc::double_field_acquire(int offset) const { return OrderAccess::load_acquire(double_field_addr(offset)); } | |
435 inline void oopDesc::release_double_field_put(int offset, jdouble contents) { OrderAccess::release_store(double_field_addr(offset), contents); } | |
436 | |
710 | 437 inline address oopDesc::address_field_acquire(int offset) const { return (address) OrderAccess::load_ptr_acquire(address_field_addr(offset)); } |
438 inline void oopDesc::release_address_field_put(int offset, address contents) { OrderAccess::release_store_ptr(address_field_addr(offset), contents); } | |
439 | |
0 | 440 inline int oopDesc::size_given_klass(Klass* klass) { |
441 int lh = klass->layout_helper(); | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
442 int s; |
0 | 443 |
444 // lh is now a value computed at class initialization that may hint | |
445 // at the size. For instances, this is positive and equal to the | |
446 // size. For arrays, this is negative and provides log2 of the | |
447 // array element size. For other oops, it is zero and thus requires | |
448 // a virtual call. | |
449 // | |
450 // We go to all this trouble because the size computation is at the | |
451 // heart of phase 2 of mark-compaction, and called for every object, | |
452 // alive or dead. So the speed here is equal in importance to the | |
453 // speed of allocation. | |
454 | |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
455 if (lh > Klass::_lh_neutral_value) { |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
456 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
|
457 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
|
458 } else { |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
459 s = klass->oop_size(this); |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
460 } |
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2192
diff
changeset
|
461 } else if (lh <= Klass::_lh_neutral_value) { |
0 | 462 // The most common case is instances; fall through if so. |
463 if (lh < Klass::_lh_neutral_value) { | |
464 // Second most common case is arrays. We have to fetch the | |
465 // length of the array, shift (multiply) it appropriately, | |
466 // up to wordSize, add the header, and align to object size. | |
467 size_t size_in_bytes; | |
468 #ifdef _M_IA64 | |
469 // The Windows Itanium Aug 2002 SDK hoists this load above | |
470 // the check for s < 0. An oop at the end of the heap will | |
471 // cause an access violation if this load is performed on a non | |
472 // array oop. Making the reference volatile prohibits this. | |
473 // (%%% please explain by what magic the length is actually fetched!) | |
474 volatile int *array_length; | |
475 array_length = (volatile int *)( (intptr_t)this + | |
476 arrayOopDesc::length_offset_in_bytes() ); | |
477 assert(array_length > 0, "Integer arithmetic problem somewhere"); | |
478 // Put into size_t to avoid overflow. | |
479 size_in_bytes = (size_t) array_length; | |
480 size_in_bytes = size_in_bytes << Klass::layout_helper_log2_element_size(lh); | |
481 #else | |
482 size_t array_length = (size_t) ((arrayOop)this)->length(); | |
483 size_in_bytes = array_length << Klass::layout_helper_log2_element_size(lh); | |
484 #endif | |
485 size_in_bytes += Klass::layout_helper_header_size(lh); | |
486 | |
487 // This code could be simplified, but by keeping array_header_in_bytes | |
488 // in units of bytes and doing it this way we can round up just once, | |
489 // skipping the intermediate round to HeapWordSize. Cast the result | |
490 // of round_to to size_t to guarantee unsigned division == right shift. | |
491 s = (int)((size_t)round_to(size_in_bytes, MinObjAlignmentInBytes) / | |
492 HeapWordSize); | |
493 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
494 // UseParNewGC, UseParallelGC and UseG1GC can change the length field |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
495 // 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
|
496 // 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
|
497 // 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
|
498 // a concurrent change. |
0 | 499 // UseParNewGC also runs with promotion labs (which look like int |
500 // filler arrays) which are subject to changing their declared size | |
501 // when finally retiring a PLAB; this also can cause the first disjunct | |
502 // to fail for another worker thread that is concurrently walking the block | |
503 // offset table. Both these invariant failures are benign for their | |
504 // current uses; we relax the assertion checking to cover these two cases below: | |
505 // is_objArray() && is_forwarded() // covers first scenario above | |
506 // || is_typeArray() // covers second scenario above | |
507 // 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
|
508 // technique, we will need to suitably modify the assertion. |
0 | 509 assert((s == klass->oop_size(this)) || |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
510 (Universe::heap()->is_gc_active() && |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
511 ((is_typeArray() && UseParNewGC) || |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
512 (is_objArray() && is_forwarded() && (UseParNewGC || UseParallelGC || UseG1GC)))), |
0 | 513 "wrong array object size"); |
514 } else { | |
515 // Must be zero, so bite the bullet and take the virtual call. | |
516 s = klass->oop_size(this); | |
517 } | |
518 } | |
519 | |
520 assert(s % MinObjAlignment == 0, "alignment check"); | |
521 assert(s > 0, "Bad size calculated"); | |
522 return s; | |
523 } | |
524 | |
525 | |
526 inline int oopDesc::size() { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
527 return size_given_klass(klass()); |
518
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
454
diff
changeset
|
528 } |
0af8b0718fc9
6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark"
jmasa
parents:
454
diff
changeset
|
529 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
530 inline void update_barrier_set(void* p, oop v) { |
0 | 531 assert(oopDesc::bs() != NULL, "Uninitialized bs in oop!"); |
532 oopDesc::bs()->write_ref_field(p, v); | |
533 } | |
534 | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
710
diff
changeset
|
535 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
|
536 oopDesc::bs()->write_ref_field_pre(p, v); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
537 } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
538 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
539 template <class T> inline void oop_store(T* p, oop v) { |
0 | 540 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
|
541 oop_store((volatile T*)p, v); |
0 | 542 } else { |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
543 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
|
544 oopDesc::encode_store_heap_oop(p, v); |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
710
diff
changeset
|
545 update_barrier_set((void*)p, v); // cast away type |
0 | 546 } |
547 } | |
548 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
549 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
|
550 update_barrier_set_pre((T*)p, v); // cast away volatile |
0 | 551 // 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
|
552 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
|
553 update_barrier_set((void*)p, v); // cast away type |
0 | 554 } |
555 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
556 // 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
|
557 // (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
|
558 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
|
559 if (UseCompressedOops) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
560 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
|
561 } else { |
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((oop*)addr, value); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
563 } |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
564 } |
0 | 565 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
566 inline oop oopDesc::atomic_compare_exchange_oop(oop exchange_value, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
567 volatile HeapWord *dest, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
568 oop compare_value, |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
569 bool prebarrier) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
570 if (UseCompressedOops) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
571 if (prebarrier) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
572 update_barrier_set_pre((narrowOop*)dest, exchange_value); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
573 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
574 // encode exchange and compare value from oop to T |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
575 narrowOop val = encode_heap_oop(exchange_value); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
576 narrowOop cmp = encode_heap_oop(compare_value); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
577 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
578 narrowOop old = (narrowOop) Atomic::cmpxchg(val, (narrowOop*)dest, cmp); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
579 // decode old from T to oop |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
580 return decode_heap_oop(old); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
581 } else { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
582 if (prebarrier) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
583 update_barrier_set_pre((oop*)dest, exchange_value); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
584 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
585 return (oop)Atomic::cmpxchg_ptr(exchange_value, (oop*)dest, compare_value); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
586 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
587 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
588 |
0 | 589 // Used only for markSweep, scavenging |
590 inline bool oopDesc::is_gc_marked() const { | |
591 return mark()->is_marked(); | |
592 } | |
593 | |
594 inline bool oopDesc::is_locked() const { | |
595 return mark()->is_locked(); | |
596 } | |
597 | |
598 inline bool oopDesc::is_unlocked() const { | |
599 return mark()->is_unlocked(); | |
600 } | |
601 | |
602 inline bool oopDesc::has_bias_pattern() const { | |
603 return mark()->has_bias_pattern(); | |
604 } | |
605 | |
606 | |
607 // used only for asserts | |
608 inline bool oopDesc::is_oop(bool ignore_mark_word) const { | |
609 oop obj = (oop) this; | |
610 if (!check_obj_alignment(obj)) return false; | |
611 if (!Universe::heap()->is_in_reserved(obj)) return false; | |
612 // obj is aligned and accessible in heap | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
613 if (Universe::heap()->is_in_reserved(obj->klass_or_null())) return false; |
0 | 614 |
615 // Header verification: the mark is typically non-NULL. If we're | |
616 // at a safepoint, it must not be null. | |
617 // Outside of a safepoint, the header could be changing (for example, | |
618 // another thread could be inflating a lock on this object). | |
619 if (ignore_mark_word) { | |
620 return true; | |
621 } | |
622 if (mark() != NULL) { | |
623 return true; | |
624 } | |
625 return !SafepointSynchronize::is_at_safepoint(); | |
626 } | |
627 | |
628 | |
629 // used only for asserts | |
630 inline bool oopDesc::is_oop_or_null(bool ignore_mark_word) const { | |
631 return this == NULL ? true : is_oop(ignore_mark_word); | |
632 } | |
633 | |
634 #ifndef PRODUCT | |
635 // used only for asserts | |
636 inline bool oopDesc::is_unlocked_oop() const { | |
637 if (!Universe::heap()->is_in_reserved(this)) return false; | |
638 return mark()->is_unlocked(); | |
639 } | |
640 #endif // PRODUCT | |
641 | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
642 inline void oopDesc::follow_contents(void) { |
0 | 643 assert (is_gc_marked(), "should be marked"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
644 klass()->oop_follow_contents(this); |
0 | 645 } |
646 | |
647 // Used by scavengers | |
648 | |
649 inline bool oopDesc::is_forwarded() const { | |
650 // The extra heap check is needed since the obj might be locked, in which case the | |
651 // mark would point to a stack location and have the sentinel bit cleared | |
652 return mark()->is_marked(); | |
653 } | |
654 | |
655 // Used by scavengers | |
656 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
|
657 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
|
658 "forwarding to something not aligned"); |
0 | 659 assert(Universe::heap()->is_in_reserved(p), |
660 "forwarding to something not in heap"); | |
661 markOop m = markOopDesc::encode_pointer_as_mark(p); | |
662 assert(m->decode_pointer() == p, "encoding must be reversable"); | |
663 set_mark(m); | |
664 } | |
665 | |
666 // Used by parallel scavengers | |
667 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
|
668 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
|
669 "forwarding to something not aligned"); |
0 | 670 assert(Universe::heap()->is_in_reserved(p), |
671 "forwarding to something not in heap"); | |
672 markOop m = markOopDesc::encode_pointer_as_mark(p); | |
673 assert(m->decode_pointer() == p, "encoding must be reversable"); | |
674 return cas_set_mark(m, compare) == compare; | |
675 } | |
676 | |
677 // Note that the forwardee is not the same thing as the displaced_mark. | |
678 // The forwardee is used when copying during scavenge and mark-sweep. | |
679 // 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
|
680 inline oop oopDesc::forwardee() const { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
681 return (oop) mark()->decode_pointer(); |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
682 } |
0 | 683 |
684 inline bool oopDesc::has_displaced_mark() const { | |
685 return mark()->has_displaced_mark_helper(); | |
686 } | |
687 | |
688 inline markOop oopDesc::displaced_mark() const { | |
689 return mark()->displaced_mark_helper(); | |
690 } | |
691 | |
692 inline void oopDesc::set_displaced_mark(markOop m) { | |
693 mark()->set_displaced_mark_helper(m); | |
694 } | |
695 | |
696 // The following method needs to be MT safe. | |
6818 | 697 inline uint oopDesc::age() const { |
0 | 698 assert(!is_forwarded(), "Attempt to read age from forwarded mark"); |
699 if (has_displaced_mark()) { | |
700 return displaced_mark()->age(); | |
701 } else { | |
702 return mark()->age(); | |
703 } | |
704 } | |
705 | |
706 inline void oopDesc::incr_age() { | |
707 assert(!is_forwarded(), "Attempt to increment age of forwarded mark"); | |
708 if (has_displaced_mark()) { | |
709 set_displaced_mark(displaced_mark()->incr_age()); | |
710 } else { | |
711 set_mark(mark()->incr_age()); | |
712 } | |
713 } | |
714 | |
715 | |
716 inline intptr_t oopDesc::identity_hash() { | |
717 // Fast case; if the object is unlocked and the hash value is set, no locking is needed | |
718 // Note: The mark must be read into local variable to avoid concurrent updates. | |
719 markOop mrk = mark(); | |
720 if (mrk->is_unlocked() && !mrk->has_no_hash()) { | |
721 return mrk->hash(); | |
722 } else if (mrk->is_marked()) { | |
723 return mrk->hash(); | |
724 } else { | |
725 return slow_identity_hash(); | |
726 } | |
727 } | |
728 | |
729 inline int oopDesc::adjust_pointers() { | |
730 debug_only(int check_size = size()); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
731 int s = klass()->oop_adjust_pointers(this); |
0 | 732 assert(s == check_size, "should be the same"); |
733 return s; | |
734 } | |
735 | |
736 #define OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ | |
737 \ | |
738 inline int oopDesc::oop_iterate(OopClosureType* blk) { \ | |
739 SpecializationStats::record_call(); \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
740 return klass()->oop_oop_iterate##nv_suffix(this, blk); \ |
0 | 741 } \ |
742 \ | |
743 inline int oopDesc::oop_iterate(OopClosureType* blk, MemRegion mr) { \ | |
744 SpecializationStats::record_call(); \ | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
745 return klass()->oop_oop_iterate##nv_suffix##_m(this, blk, mr); \ |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
746 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
747 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
748 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
749 inline int oopDesc::oop_iterate_no_header(OopClosure* blk) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
750 // The NoHeaderExtendedOopClosure wraps the OopClosure and proxies all |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
751 // the do_oop calls, but turns off all other features in ExtendedOopClosure. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
752 NoHeaderExtendedOopClosure cl(blk); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
753 return oop_iterate(&cl); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
754 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
755 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
756 inline int oopDesc::oop_iterate_no_header(OopClosure* blk, MemRegion mr) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
757 NoHeaderExtendedOopClosure cl(blk); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
758 return oop_iterate(&cl, mr); |
0 | 759 } |
760 | |
761 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DEFN) | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
762 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DEFN) |
0 | 763 |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6848
diff
changeset
|
764 #if INCLUDE_ALL_GCS |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
765 #define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
766 \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
767 inline int oopDesc::oop_iterate_backwards(OopClosureType* blk) { \ |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
768 SpecializationStats::record_call(); \ |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3932
diff
changeset
|
769 return klass()->oop_oop_iterate_backwards##nv_suffix(this, blk); \ |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
770 } |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
771 |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
772 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DEFN) |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
135
diff
changeset
|
773 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DEFN) |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
6848
diff
changeset
|
774 #endif // INCLUDE_ALL_GCS |
0 | 775 |
1972 | 776 #endif // SHARE_VM_OOPS_OOP_INLINE_HPP |