Mercurial > hg > truffle
annotate src/share/vm/memory/universe.cpp @ 12233:40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation.
Reviewed-by: stefank, dholmes
author | tschatzl |
---|---|
date | Wed, 11 Sep 2013 16:25:02 +0200 |
parents | 7944aba7ba41 |
children | 23ae5a04724d |
rev | line source |
---|---|
0 | 1 /* |
7623
203f64878aab
7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents:
7187
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:
1507
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1507
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:
1507
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "classfile/classLoader.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
27 #include "classfile/classLoaderData.hpp" |
1972 | 28 #include "classfile/javaClasses.hpp" |
29 #include "classfile/symbolTable.hpp" | |
30 #include "classfile/systemDictionary.hpp" | |
31 #include "classfile/vmSymbols.hpp" | |
32 #include "code/codeCache.hpp" | |
33 #include "code/dependencies.hpp" | |
34 #include "gc_interface/collectedHeap.inline.hpp" | |
35 #include "interpreter/interpreter.hpp" | |
36 #include "memory/cardTableModRefBS.hpp" | |
37 #include "memory/gcLocker.inline.hpp" | |
38 #include "memory/genCollectedHeap.hpp" | |
39 #include "memory/genRemSet.hpp" | |
40 #include "memory/generation.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
41 #include "memory/metadataFactory.hpp" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
42 #include "memory/metaspaceShared.hpp" |
1972 | 43 #include "memory/oopFactory.hpp" |
44 #include "memory/space.hpp" | |
45 #include "memory/universe.hpp" | |
46 #include "memory/universe.inline.hpp" | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
47 #include "oops/constantPool.hpp" |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
48 #include "oops/instanceClassLoaderKlass.hpp" |
1972 | 49 #include "oops/instanceKlass.hpp" |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2375
diff
changeset
|
50 #include "oops/instanceMirrorKlass.hpp" |
1972 | 51 #include "oops/instanceRefKlass.hpp" |
52 #include "oops/oop.inline.hpp" | |
53 #include "oops/typeArrayKlass.hpp" | |
54 #include "prims/jvmtiRedefineClassesTrace.hpp" | |
55 #include "runtime/arguments.hpp" | |
56 #include "runtime/deoptimization.hpp" | |
57 #include "runtime/fprofiler.hpp" | |
58 #include "runtime/handles.inline.hpp" | |
59 #include "runtime/init.hpp" | |
60 #include "runtime/java.hpp" | |
61 #include "runtime/javaCalls.hpp" | |
62 #include "runtime/sharedRuntime.hpp" | |
63 #include "runtime/synchronizer.hpp" | |
7180
f34d701e952e
8003935: Simplify the needed includes for using Thread::current()
stefank
parents:
6985
diff
changeset
|
64 #include "runtime/thread.inline.hpp" |
1972 | 65 #include "runtime/timer.hpp" |
66 #include "runtime/vm_operations.hpp" | |
67 #include "services/memoryService.hpp" | |
68 #include "utilities/copy.hpp" | |
69 #include "utilities/events.hpp" | |
70 #include "utilities/hashtable.inline.hpp" | |
71 #include "utilities/preserveException.hpp" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
72 #include "utilities/macros.hpp" |
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
73 #if INCLUDE_ALL_GCS |
1972 | 74 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp" |
75 #include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp" | |
76 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
77 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
78 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
79 #endif // INCLUDE_ALL_GCS |
0 | 80 |
81 // Known objects | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
82 Klass* Universe::_boolArrayKlassObj = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
83 Klass* Universe::_byteArrayKlassObj = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
84 Klass* Universe::_charArrayKlassObj = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
85 Klass* Universe::_intArrayKlassObj = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
86 Klass* Universe::_shortArrayKlassObj = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
87 Klass* Universe::_longArrayKlassObj = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
88 Klass* Universe::_singleArrayKlassObj = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
89 Klass* Universe::_doubleArrayKlassObj = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
90 Klass* Universe::_typeArrayKlassObjs[T_VOID+1] = { NULL /*, NULL...*/ }; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
91 Klass* Universe::_objectArrayKlassObj = NULL; |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
92 oop Universe::_int_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
93 oop Universe::_float_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
94 oop Universe::_double_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
95 oop Universe::_byte_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
96 oop Universe::_bool_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
97 oop Universe::_char_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
98 oop Universe::_long_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
99 oop Universe::_short_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
100 oop Universe::_void_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
101 oop Universe::_mirrors[T_VOID+1] = { NULL /*, NULL...*/ }; |
0 | 102 oop Universe::_main_thread_group = NULL; |
103 oop Universe::_system_thread_group = NULL; | |
104 objArrayOop Universe::_the_empty_class_klass_array = NULL; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
105 Array<Klass*>* Universe::_the_array_interfaces_array = NULL; |
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
106 oop Universe::_the_null_string = NULL; |
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
107 oop Universe::_the_min_jint_string = NULL; |
12022
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
108 LatestMethodCache* Universe::_finalizer_register_cache = NULL; |
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
109 LatestMethodCache* Universe::_loader_addClass_cache = NULL; |
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
110 LatestMethodCache* Universe::_pd_implies_cache = NULL; |
0 | 111 oop Universe::_out_of_memory_error_java_heap = NULL; |
11064
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
112 oop Universe::_out_of_memory_error_metaspace = NULL; |
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
113 oop Universe::_out_of_memory_error_class_metaspace = NULL; |
0 | 114 oop Universe::_out_of_memory_error_array_size = NULL; |
115 oop Universe::_out_of_memory_error_gc_overhead_limit = NULL; | |
116 objArrayOop Universe::_preallocated_out_of_memory_error_array = NULL; | |
117 volatile jint Universe::_preallocated_out_of_memory_error_avail_count = 0; | |
118 bool Universe::_verify_in_progress = false; | |
119 oop Universe::_null_ptr_exception_instance = NULL; | |
120 oop Universe::_arithmetic_exception_instance = NULL; | |
121 oop Universe::_virtual_machine_error_instance = NULL; | |
122 oop Universe::_vm_exception = NULL; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
123 Array<int>* Universe::_the_empty_int_array = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
124 Array<u2>* Universe::_the_empty_short_array = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
125 Array<Klass*>* Universe::_the_empty_klass_array = NULL; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
126 Array<Method*>* Universe::_the_empty_method_array = NULL; |
0 | 127 |
128 // These variables are guarded by FullGCALot_lock. | |
129 debug_only(objArrayOop Universe::_fullgc_alot_dummy_array = NULL;) | |
130 debug_only(int Universe::_fullgc_alot_dummy_next = 0;) | |
131 | |
132 // Heap | |
133 int Universe::_verify_count = 0; | |
134 | |
135 int Universe::_base_vtable_size = 0; | |
136 bool Universe::_bootstrapping = false; | |
137 bool Universe::_fully_initialized = false; | |
138 | |
139 size_t Universe::_heap_capacity_at_last_gc; | |
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
140 size_t Universe::_heap_used_at_last_gc = 0; |
0 | 141 |
142 CollectedHeap* Universe::_collectedHeap = NULL; | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
143 |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
144 NarrowPtrStruct Universe::_narrow_oop = { NULL, 0, true }; |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
145 NarrowPtrStruct Universe::_narrow_klass = { NULL, 0, true }; |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
146 address Universe::_narrow_ptrs_base; |
0 | 147 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
148 void Universe::basic_type_classes_do(void f(Klass*)) { |
0 | 149 f(boolArrayKlassObj()); |
150 f(byteArrayKlassObj()); | |
151 f(charArrayKlassObj()); | |
152 f(intArrayKlassObj()); | |
153 f(shortArrayKlassObj()); | |
154 f(longArrayKlassObj()); | |
155 f(singleArrayKlassObj()); | |
156 f(doubleArrayKlassObj()); | |
157 } | |
158 | |
159 void Universe::oops_do(OopClosure* f, bool do_all) { | |
160 | |
161 f->do_oop((oop*) &_int_mirror); | |
162 f->do_oop((oop*) &_float_mirror); | |
163 f->do_oop((oop*) &_double_mirror); | |
164 f->do_oop((oop*) &_byte_mirror); | |
165 f->do_oop((oop*) &_bool_mirror); | |
166 f->do_oop((oop*) &_char_mirror); | |
167 f->do_oop((oop*) &_long_mirror); | |
168 f->do_oop((oop*) &_short_mirror); | |
169 f->do_oop((oop*) &_void_mirror); | |
170 | |
171 for (int i = T_BOOLEAN; i < T_VOID+1; i++) { | |
172 f->do_oop((oop*) &_mirrors[i]); | |
173 } | |
174 assert(_mirrors[0] == NULL && _mirrors[T_BOOLEAN - 1] == NULL, "checking"); | |
175 | |
176 f->do_oop((oop*)&_the_empty_class_klass_array); | |
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
177 f->do_oop((oop*)&_the_null_string); |
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
178 f->do_oop((oop*)&_the_min_jint_string); |
0 | 179 f->do_oop((oop*)&_out_of_memory_error_java_heap); |
11064
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
180 f->do_oop((oop*)&_out_of_memory_error_metaspace); |
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
181 f->do_oop((oop*)&_out_of_memory_error_class_metaspace); |
0 | 182 f->do_oop((oop*)&_out_of_memory_error_array_size); |
183 f->do_oop((oop*)&_out_of_memory_error_gc_overhead_limit); | |
184 f->do_oop((oop*)&_preallocated_out_of_memory_error_array); | |
185 f->do_oop((oop*)&_null_ptr_exception_instance); | |
186 f->do_oop((oop*)&_arithmetic_exception_instance); | |
187 f->do_oop((oop*)&_virtual_machine_error_instance); | |
188 f->do_oop((oop*)&_main_thread_group); | |
189 f->do_oop((oop*)&_system_thread_group); | |
190 f->do_oop((oop*)&_vm_exception); | |
191 debug_only(f->do_oop((oop*)&_fullgc_alot_dummy_array);) | |
192 } | |
193 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
194 // Serialize metadata in and out of CDS archive, not oops. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
195 void Universe::serialize(SerializeClosure* f, bool do_all) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
196 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
197 f->do_ptr((void**)&_boolArrayKlassObj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
198 f->do_ptr((void**)&_byteArrayKlassObj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
199 f->do_ptr((void**)&_charArrayKlassObj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
200 f->do_ptr((void**)&_intArrayKlassObj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
201 f->do_ptr((void**)&_shortArrayKlassObj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
202 f->do_ptr((void**)&_longArrayKlassObj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
203 f->do_ptr((void**)&_singleArrayKlassObj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
204 f->do_ptr((void**)&_doubleArrayKlassObj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
205 f->do_ptr((void**)&_objectArrayKlassObj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
206 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
207 { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
208 for (int i = 0; i < T_VOID+1; i++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
209 if (_typeArrayKlassObjs[i] != NULL) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
210 assert(i >= T_BOOLEAN, "checking"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
211 f->do_ptr((void**)&_typeArrayKlassObjs[i]); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
212 } else if (do_all) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
213 f->do_ptr((void**)&_typeArrayKlassObjs[i]); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
214 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
215 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
216 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
217 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
218 f->do_ptr((void**)&_the_array_interfaces_array); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
219 f->do_ptr((void**)&_the_empty_int_array); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
220 f->do_ptr((void**)&_the_empty_short_array); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
221 f->do_ptr((void**)&_the_empty_method_array); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
222 f->do_ptr((void**)&_the_empty_klass_array); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
223 _finalizer_register_cache->serialize(f); |
6751
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6736
diff
changeset
|
224 _loader_addClass_cache->serialize(f); |
11010 | 225 _pd_implies_cache->serialize(f); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
226 } |
0 | 227 |
228 void Universe::check_alignment(uintx size, uintx alignment, const char* name) { | |
229 if (size < alignment || size % alignment != 0) { | |
10358
0def34ab1c98
8015007: Incorrect print format in error message for VM cannot allocate the requested heap
tamao
parents:
10265
diff
changeset
|
230 vm_exit_during_initialization( |
0def34ab1c98
8015007: Incorrect print format in error message for VM cannot allocate the requested heap
tamao
parents:
10265
diff
changeset
|
231 err_msg("Size of %s (" UINTX_FORMAT " bytes) must be aligned to " UINTX_FORMAT " bytes", name, size, alignment)); |
0 | 232 } |
233 } | |
234 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
235 void initialize_basic_type_klass(Klass* k, TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
236 Klass* ok = SystemDictionary::Object_klass(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
237 if (UseSharedSpaces) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
238 assert(k->super() == ok, "u3"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
239 k->restore_unshareable_info(CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
240 } else { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
241 k->initialize_supers(ok, CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
242 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
243 k->append_to_sibling_list(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
244 } |
0 | 245 |
246 void Universe::genesis(TRAPS) { | |
247 ResourceMark rm; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
248 |
0 | 249 { FlagSetting fs(_bootstrapping, true); |
250 | |
251 { MutexLocker mc(Compile_lock); | |
252 | |
253 // determine base vtable size; without that we cannot create the array klasses | |
254 compute_base_vtable_size(); | |
255 | |
256 if (!UseSharedSpaces) { | |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
257 _boolArrayKlassObj = TypeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK); |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
258 _charArrayKlassObj = TypeArrayKlass::create_klass(T_CHAR, sizeof(jchar), CHECK); |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
259 _singleArrayKlassObj = TypeArrayKlass::create_klass(T_FLOAT, sizeof(jfloat), CHECK); |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
260 _doubleArrayKlassObj = TypeArrayKlass::create_klass(T_DOUBLE, sizeof(jdouble), CHECK); |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
261 _byteArrayKlassObj = TypeArrayKlass::create_klass(T_BYTE, sizeof(jbyte), CHECK); |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
262 _shortArrayKlassObj = TypeArrayKlass::create_klass(T_SHORT, sizeof(jshort), CHECK); |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
263 _intArrayKlassObj = TypeArrayKlass::create_klass(T_INT, sizeof(jint), CHECK); |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
264 _longArrayKlassObj = TypeArrayKlass::create_klass(T_LONG, sizeof(jlong), CHECK); |
0 | 265 |
266 _typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj; | |
267 _typeArrayKlassObjs[T_CHAR] = _charArrayKlassObj; | |
268 _typeArrayKlassObjs[T_FLOAT] = _singleArrayKlassObj; | |
269 _typeArrayKlassObjs[T_DOUBLE] = _doubleArrayKlassObj; | |
270 _typeArrayKlassObjs[T_BYTE] = _byteArrayKlassObj; | |
271 _typeArrayKlassObjs[T_SHORT] = _shortArrayKlassObj; | |
272 _typeArrayKlassObjs[T_INT] = _intArrayKlassObj; | |
273 _typeArrayKlassObjs[T_LONG] = _longArrayKlassObj; | |
274 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
275 ClassLoaderData* null_cld = ClassLoaderData::the_null_class_loader_data(); |
0 | 276 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
277 _the_array_interfaces_array = MetadataFactory::new_array<Klass*>(null_cld, 2, NULL, CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
278 _the_empty_int_array = MetadataFactory::new_array<int>(null_cld, 0, CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
279 _the_empty_short_array = MetadataFactory::new_array<u2>(null_cld, 0, CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
280 _the_empty_method_array = MetadataFactory::new_array<Method*>(null_cld, 0, CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
281 _the_empty_klass_array = MetadataFactory::new_array<Klass*>(null_cld, 0, CHECK); |
0 | 282 } |
283 } | |
284 | |
285 vmSymbols::initialize(CHECK); | |
286 | |
287 SystemDictionary::initialize(CHECK); | |
288 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
289 Klass* ok = SystemDictionary::Object_klass(); |
0 | 290 |
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
291 _the_null_string = StringTable::intern("null", CHECK); |
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
292 _the_min_jint_string = StringTable::intern("-2147483648", CHECK); |
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
293 |
0 | 294 if (UseSharedSpaces) { |
295 // Verify shared interfaces array. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
296 assert(_the_array_interfaces_array->at(0) == |
1142 | 297 SystemDictionary::Cloneable_klass(), "u3"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
298 assert(_the_array_interfaces_array->at(1) == |
1142 | 299 SystemDictionary::Serializable_klass(), "u3"); |
0 | 300 } else { |
301 // Set up shared interfaces array. (Do this before supers are set up.) | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
302 _the_array_interfaces_array->at_put(0, SystemDictionary::Cloneable_klass()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
303 _the_array_interfaces_array->at_put(1, SystemDictionary::Serializable_klass()); |
0 | 304 } |
305 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
306 initialize_basic_type_klass(boolArrayKlassObj(), CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
307 initialize_basic_type_klass(charArrayKlassObj(), CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
308 initialize_basic_type_klass(singleArrayKlassObj(), CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
309 initialize_basic_type_klass(doubleArrayKlassObj(), CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
310 initialize_basic_type_klass(byteArrayKlassObj(), CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
311 initialize_basic_type_klass(shortArrayKlassObj(), CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
312 initialize_basic_type_klass(intArrayKlassObj(), CHECK); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
313 initialize_basic_type_klass(longArrayKlassObj(), CHECK); |
0 | 314 } // end of core bootstrapping |
315 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
316 // Maybe this could be lifted up now that object array can be initialized |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
317 // during the bootstrapping. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
318 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
319 // OLD |
0 | 320 // Initialize _objectArrayKlass after core bootstraping to make |
321 // sure the super class is set up properly for _objectArrayKlass. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
322 // --- |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
323 // NEW |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
324 // Since some of the old system object arrays have been converted to |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
325 // ordinary object arrays, _objectArrayKlass will be loaded when |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
326 // SystemDictionary::initialize(CHECK); is run. See the extra check |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
327 // for Object_klass_loaded in objArrayKlassKlass::allocate_objArray_klass_impl. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
328 _objectArrayKlassObj = InstanceKlass:: |
1142 | 329 cast(SystemDictionary::Object_klass())->array_klass(1, CHECK); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
330 // OLD |
0 | 331 // Add the class to the class hierarchy manually to make sure that |
332 // its vtable is initialized after core bootstrapping is completed. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
333 // --- |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
334 // New |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
335 // Have already been initialized. |
6983 | 336 _objectArrayKlassObj->append_to_sibling_list(); |
0 | 337 |
338 // Compute is_jdk version flags. | |
339 // Only 1.3 or later has the java.lang.Shutdown class. | |
340 // Only 1.4 or later has the java.lang.CharSequence interface. | |
341 // Only 1.5 or later has the java.lang.management.MemoryUsage class. | |
242 | 342 if (JDK_Version::is_partially_initialized()) { |
343 uint8_t jdk_version; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
344 Klass* k = SystemDictionary::resolve_or_null( |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
345 vmSymbols::java_lang_management_MemoryUsage(), THREAD); |
0 | 346 CLEAR_PENDING_EXCEPTION; // ignore exceptions |
347 if (k == NULL) { | |
242 | 348 k = SystemDictionary::resolve_or_null( |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
349 vmSymbols::java_lang_CharSequence(), THREAD); |
0 | 350 CLEAR_PENDING_EXCEPTION; // ignore exceptions |
351 if (k == NULL) { | |
242 | 352 k = SystemDictionary::resolve_or_null( |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
353 vmSymbols::java_lang_Shutdown(), THREAD); |
0 | 354 CLEAR_PENDING_EXCEPTION; // ignore exceptions |
355 if (k == NULL) { | |
242 | 356 jdk_version = 2; |
0 | 357 } else { |
242 | 358 jdk_version = 3; |
0 | 359 } |
360 } else { | |
242 | 361 jdk_version = 4; |
0 | 362 } |
363 } else { | |
242 | 364 jdk_version = 5; |
0 | 365 } |
242 | 366 JDK_Version::fully_initialize(jdk_version); |
0 | 367 } |
368 | |
369 #ifdef ASSERT | |
370 if (FullGCALot) { | |
371 // Allocate an array of dummy objects. | |
372 // We'd like these to be at the bottom of the old generation, | |
373 // so that when we free one and then collect, | |
374 // (almost) the whole heap moves | |
375 // and we find out if we actually update all the oops correctly. | |
376 // But we can't allocate directly in the old generation, | |
377 // so we allocate wherever, and hope that the first collection | |
378 // moves these objects to the bottom of the old generation. | |
379 // We can allocate directly in the permanent generation, so we do. | |
380 int size; | |
381 if (UseConcMarkSweepGC) { | |
382 warning("Using +FullGCALot with concurrent mark sweep gc " | |
383 "will not force all objects to relocate"); | |
384 size = FullGCALotDummies; | |
385 } else { | |
386 size = FullGCALotDummies * 2; | |
387 } | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
388 objArrayOop naked_array = oopFactory::new_objArray(SystemDictionary::Object_klass(), size, CHECK); |
0 | 389 objArrayHandle dummy_array(THREAD, naked_array); |
390 int i = 0; | |
391 while (i < size) { | |
392 // Allocate dummy in old generation | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
393 oop dummy = InstanceKlass::cast(SystemDictionary::Object_klass())->allocate_instance(CHECK); |
0 | 394 dummy_array->obj_at_put(i++, dummy); |
395 } | |
396 { | |
397 // Only modify the global variable inside the mutex. | |
398 // If we had a race to here, the other dummy_array instances | |
399 // and their elements just get dropped on the floor, which is fine. | |
400 MutexLocker ml(FullGCALot_lock); | |
401 if (_fullgc_alot_dummy_array == NULL) { | |
402 _fullgc_alot_dummy_array = dummy_array(); | |
403 } | |
404 } | |
405 assert(i == _fullgc_alot_dummy_array->length(), "just checking"); | |
406 } | |
407 #endif | |
7185
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
7180
diff
changeset
|
408 |
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
7180
diff
changeset
|
409 // Initialize dependency array for null class loader |
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
7180
diff
changeset
|
410 ClassLoaderData::the_null_class_loader_data()->init_dependencies(CHECK); |
90273fc0a981
8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents:
7180
diff
changeset
|
411 |
0 | 412 } |
413 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
414 // CDS support for patching vtables in metadata in the shared archive. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
415 // All types inherited from Metadata have vtables, but not types inherited |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
416 // from MetaspaceObj, because the latter does not have virtual functions. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
417 // If the metadata type has a vtable, it cannot be shared in the read-only |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
418 // section of the CDS archive, because the vtable pointer is patched. |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
419 static inline void add_vtable(void** list, int* n, void* o, int count) { |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
420 guarantee((*n) < count, "vtable list too small"); |
7176
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6985
diff
changeset
|
421 void* vtable = dereference_vptr(o); |
59c790074993
8003635: NPG: AsynchGetCallTrace broken by Method* virtual call
coleenp
parents:
6985
diff
changeset
|
422 assert(*(void**)(vtable) != NULL, "invalid vtable"); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
423 list[(*n)++] = vtable; |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
424 } |
0 | 425 |
426 void Universe::init_self_patching_vtbl_list(void** list, int count) { | |
427 int n = 0; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
428 { InstanceKlass o; add_vtable(list, &n, &o, count); } |
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
429 { InstanceClassLoaderKlass o; add_vtable(list, &n, &o, count); } |
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
430 { InstanceMirrorKlass o; add_vtable(list, &n, &o, count); } |
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
431 { InstanceRefKlass o; add_vtable(list, &n, &o, count); } |
6831
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
432 { TypeArrayKlass o; add_vtable(list, &n, &o, count); } |
d8ce2825b193
8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents:
6751
diff
changeset
|
433 { ObjArrayKlass o; add_vtable(list, &n, &o, count); } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
434 { Method o; add_vtable(list, &n, &o, count); } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
435 { ConstantPool o; add_vtable(list, &n, &o, count); } |
0 | 436 } |
437 | |
438 void Universe::initialize_basic_type_mirrors(TRAPS) { | |
439 assert(_int_mirror==NULL, "basic type mirrors already initialized"); | |
440 _int_mirror = | |
441 java_lang_Class::create_basic_type_mirror("int", T_INT, CHECK); | |
442 _float_mirror = | |
443 java_lang_Class::create_basic_type_mirror("float", T_FLOAT, CHECK); | |
444 _double_mirror = | |
445 java_lang_Class::create_basic_type_mirror("double", T_DOUBLE, CHECK); | |
446 _byte_mirror = | |
447 java_lang_Class::create_basic_type_mirror("byte", T_BYTE, CHECK); | |
448 _bool_mirror = | |
449 java_lang_Class::create_basic_type_mirror("boolean",T_BOOLEAN, CHECK); | |
450 _char_mirror = | |
451 java_lang_Class::create_basic_type_mirror("char", T_CHAR, CHECK); | |
452 _long_mirror = | |
453 java_lang_Class::create_basic_type_mirror("long", T_LONG, CHECK); | |
454 _short_mirror = | |
455 java_lang_Class::create_basic_type_mirror("short", T_SHORT, CHECK); | |
456 _void_mirror = | |
457 java_lang_Class::create_basic_type_mirror("void", T_VOID, CHECK); | |
458 | |
459 _mirrors[T_INT] = _int_mirror; | |
460 _mirrors[T_FLOAT] = _float_mirror; | |
461 _mirrors[T_DOUBLE] = _double_mirror; | |
462 _mirrors[T_BYTE] = _byte_mirror; | |
463 _mirrors[T_BOOLEAN] = _bool_mirror; | |
464 _mirrors[T_CHAR] = _char_mirror; | |
465 _mirrors[T_LONG] = _long_mirror; | |
466 _mirrors[T_SHORT] = _short_mirror; | |
467 _mirrors[T_VOID] = _void_mirror; | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
468 //_mirrors[T_OBJECT] = InstanceKlass::cast(_object_klass)->java_mirror(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
469 //_mirrors[T_ARRAY] = InstanceKlass::cast(_object_klass)->java_mirror(); |
0 | 470 } |
471 | |
472 void Universe::fixup_mirrors(TRAPS) { | |
473 // Bootstrap problem: all classes gets a mirror (java.lang.Class instance) assigned eagerly, | |
474 // but we cannot do that for classes created before java.lang.Class is loaded. Here we simply | |
475 // walk over permanent objects created so far (mostly classes) and fixup their mirrors. Note | |
476 // that the number of objects allocated at this point is very small. | |
1142 | 477 assert(SystemDictionary::Class_klass_loaded(), "java.lang.Class should be loaded"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
478 HandleMark hm(THREAD); |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2375
diff
changeset
|
479 // Cache the start of the static fields |
6735
aed758eda82a
7195833: NPG: Rename instanceClassLoaderKlass, instanceRefKlass and instanceMirrorKlass
coleenp
parents:
6725
diff
changeset
|
480 InstanceMirrorKlass::init_offset_of_static_fields(); |
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2375
diff
changeset
|
481 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
482 GrowableArray <Klass*>* list = java_lang_Class::fixup_mirror_list(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
483 int list_length = list->length(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
484 for (int i = 0; i < list_length; i++) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
485 Klass* k = list->at(i); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
486 assert(k->is_klass(), "List should only hold classes"); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
487 EXCEPTION_MARK; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
488 KlassHandle kh(THREAD, k); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
489 java_lang_Class::fixup_mirror(kh, CATCH); |
0 | 490 } |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
491 delete java_lang_Class::fixup_mirror_list(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
492 java_lang_Class::set_fixup_mirror_list(NULL); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
493 } |
0 | 494 |
495 static bool has_run_finalizers_on_exit = false; | |
496 | |
497 void Universe::run_finalizers_on_exit() { | |
498 if (has_run_finalizers_on_exit) return; | |
499 has_run_finalizers_on_exit = true; | |
500 | |
501 // Called on VM exit. This ought to be run in a separate thread. | |
502 if (TraceReferenceGC) tty->print_cr("Callback to run finalizers on exit"); | |
503 { | |
504 PRESERVE_EXCEPTION_MARK; | |
1142 | 505 KlassHandle finalizer_klass(THREAD, SystemDictionary::Finalizer_klass()); |
0 | 506 JavaValue result(T_VOID); |
507 JavaCalls::call_static( | |
508 &result, | |
509 finalizer_klass, | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
510 vmSymbols::run_finalizers_on_exit_name(), |
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
511 vmSymbols::void_method_signature(), |
0 | 512 THREAD |
513 ); | |
514 // Ignore any pending exceptions | |
515 CLEAR_PENDING_EXCEPTION; | |
516 } | |
517 } | |
518 | |
519 | |
520 // initialize_vtable could cause gc if | |
521 // 1) we specified true to initialize_vtable and | |
522 // 2) this ran after gc was enabled | |
523 // In case those ever change we use handles for oops | |
524 void Universe::reinitialize_vtable_of(KlassHandle k_h, TRAPS) { | |
525 // init vtable of k and all subclasses | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
526 Klass* ko = k_h(); |
0 | 527 klassVtable* vt = ko->vtable(); |
528 if (vt) vt->initialize_vtable(false, CHECK); | |
529 if (ko->oop_is_instance()) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
530 InstanceKlass* ik = (InstanceKlass*)ko; |
10973
ef57c43512d6
8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux
ccheung
parents:
10405
diff
changeset
|
531 for (KlassHandle s_h(THREAD, ik->subklass()); |
ef57c43512d6
8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux
ccheung
parents:
10405
diff
changeset
|
532 s_h() != NULL; |
ef57c43512d6
8014431: cleanup warnings indicated by the -Wunused-value compiler option on linux
ccheung
parents:
10405
diff
changeset
|
533 s_h = KlassHandle(THREAD, s_h()->next_sibling())) { |
0 | 534 reinitialize_vtable_of(s_h, CHECK); |
535 } | |
536 } | |
537 } | |
538 | |
539 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
540 void initialize_itable_for_klass(Klass* k, TRAPS) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
541 InstanceKlass::cast(k)->itable()->initialize_itable(false, CHECK); |
0 | 542 } |
543 | |
544 | |
545 void Universe::reinitialize_itables(TRAPS) { | |
546 SystemDictionary::classes_do(initialize_itable_for_klass, CHECK); | |
547 | |
548 } | |
549 | |
550 | |
551 bool Universe::on_page_boundary(void* addr) { | |
552 return ((uintptr_t) addr) % os::vm_page_size() == 0; | |
553 } | |
554 | |
555 | |
556 bool Universe::should_fill_in_stack_trace(Handle throwable) { | |
557 // never attempt to fill in the stack trace of preallocated errors that do not have | |
558 // backtrace. These errors are kept alive forever and may be "re-used" when all | |
559 // preallocated errors with backtrace have been consumed. Also need to avoid | |
560 // a potential loop which could happen if an out of memory occurs when attempting | |
561 // to allocate the backtrace. | |
562 return ((throwable() != Universe::_out_of_memory_error_java_heap) && | |
11064
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
563 (throwable() != Universe::_out_of_memory_error_metaspace) && |
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
564 (throwable() != Universe::_out_of_memory_error_class_metaspace) && |
0 | 565 (throwable() != Universe::_out_of_memory_error_array_size) && |
566 (throwable() != Universe::_out_of_memory_error_gc_overhead_limit)); | |
567 } | |
568 | |
569 | |
570 oop Universe::gen_out_of_memory_error(oop default_err) { | |
571 // generate an out of memory error: | |
572 // - if there is a preallocated error with backtrace available then return it wth | |
573 // a filled in stack trace. | |
574 // - if there are no preallocated errors with backtrace available then return | |
575 // an error without backtrace. | |
576 int next; | |
577 if (_preallocated_out_of_memory_error_avail_count > 0) { | |
578 next = (int)Atomic::add(-1, &_preallocated_out_of_memory_error_avail_count); | |
579 assert(next < (int)PreallocatedOutOfMemoryErrorCount, "avail count is corrupt"); | |
580 } else { | |
581 next = -1; | |
582 } | |
583 if (next < 0) { | |
584 // all preallocated errors have been used. | |
585 // return default | |
586 return default_err; | |
587 } else { | |
588 // get the error object at the slot and set set it to NULL so that the | |
589 // array isn't keeping it alive anymore. | |
590 oop exc = preallocated_out_of_memory_errors()->obj_at(next); | |
591 assert(exc != NULL, "slot has been used already"); | |
592 preallocated_out_of_memory_errors()->obj_at_put(next, NULL); | |
593 | |
594 // use the message from the default error | |
595 oop msg = java_lang_Throwable::message(default_err); | |
596 assert(msg != NULL, "no message"); | |
597 java_lang_Throwable::set_message(exc, msg); | |
598 | |
599 // populate the stack trace and return it. | |
600 java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(exc); | |
601 return exc; | |
602 } | |
603 } | |
604 | |
605 static intptr_t non_oop_bits = 0; | |
606 | |
607 void* Universe::non_oop_word() { | |
608 // Neither the high bits nor the low bits of this value is allowed | |
609 // to look like (respectively) the high or low bits of a real oop. | |
610 // | |
611 // High and low are CPU-specific notions, but low always includes | |
612 // the low-order bit. Since oops are always aligned at least mod 4, | |
613 // setting the low-order bit will ensure that the low half of the | |
614 // word will never look like that of a real oop. | |
615 // | |
616 // Using the OS-supplied non-memory-address word (usually 0 or -1) | |
617 // will take care of the high bits, however many there are. | |
618 | |
619 if (non_oop_bits == 0) { | |
620 non_oop_bits = (intptr_t)os::non_memory_address_word() | 1; | |
621 } | |
622 | |
623 return (void*)non_oop_bits; | |
624 } | |
625 | |
626 jint universe_init() { | |
627 assert(!Universe::_fully_initialized, "called after initialize_vtables"); | |
628 guarantee(1 << LogHeapWordSize == sizeof(HeapWord), | |
629 "LogHeapWordSize is incorrect."); | |
630 guarantee(sizeof(oop) >= sizeof(HeapWord), "HeapWord larger than oop?"); | |
631 guarantee(sizeof(oop) % sizeof(HeapWord) == 0, | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
632 "oop size is not not a multiple of HeapWord size"); |
0 | 633 TraceTime timer("Genesis", TraceStartupTime); |
634 GC_locker::lock(); // do not allow gc during bootstrapping | |
635 JavaClasses::compute_hard_coded_offsets(); | |
636 | |
637 jint status = Universe::initialize_heap(); | |
638 if (status != JNI_OK) { | |
639 return status; | |
640 } | |
641 | |
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
642 Metaspace::global_initialize(); |
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
643 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
644 // Create memory for metadata. Must be after initializing heap for |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
645 // DumpSharedSpaces. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
646 ClassLoaderData::init_null_class_loader_data(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
647 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
648 // We have a heap so create the Method* caches before |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
649 // Metaspace::initialize_shared_spaces() tries to populate them. |
12022
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
650 Universe::_finalizer_register_cache = new LatestMethodCache(); |
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
651 Universe::_loader_addClass_cache = new LatestMethodCache(); |
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
652 Universe::_pd_implies_cache = new LatestMethodCache(); |
0 | 653 |
654 if (UseSharedSpaces) { | |
655 // Read the data structures supporting the shared spaces (shared | |
656 // system dictionary, symbol table, etc.). After that, access to | |
657 // the file (other than the mapped regions) is no longer needed, and | |
658 // the file is closed. Closing the file does not affect the | |
659 // currently mapped regions. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
660 MetaspaceShared::initialize_shared_spaces(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
661 StringTable::create_table(); |
0 | 662 } else { |
663 SymbolTable::create_table(); | |
664 StringTable::create_table(); | |
665 ClassLoader::create_package_info_table(); | |
666 } | |
667 | |
668 return JNI_OK; | |
669 } | |
670 | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
671 // Choose the heap base address and oop encoding mode |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
672 // when compressed oops are used: |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
673 // Unscaled - Use 32-bits oops without encoding when |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
674 // NarrowOopHeapBaseMin + heap_size < 4Gb |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
675 // ZeroBased - Use zero based compressed oops with encoding when |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
676 // NarrowOopHeapBaseMin + heap_size < 32Gb |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
677 // HeapBased - Use compressed oops with heap base + encoding. |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
678 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
679 // 4Gb |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
680 static const uint64_t NarrowOopHeapMax = (uint64_t(max_juint) + 1); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
681 // 32Gb |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1507
diff
changeset
|
682 // OopEncodingHeapMax == NarrowOopHeapMax << LogMinObjAlignmentInBytes; |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
683 |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
684 char* Universe::preferred_heap_base(size_t heap_size, size_t alignment, NARROW_OOP_MODE mode) { |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
685 assert(is_size_aligned((size_t)OopEncodingHeapMax, alignment), "Must be"); |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
686 assert(is_size_aligned((size_t)NarrowOopHeapMax, alignment), "Must be"); |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
687 assert(is_size_aligned(heap_size, alignment), "Must be"); |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
688 |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
689 uintx heap_base_min_address_aligned = align_size_up(HeapBaseMinAddress, alignment); |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
690 |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
691 size_t base = 0; |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
692 #ifdef _LP64 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
693 if (UseCompressedOops) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
694 assert(mode == UnscaledNarrowOop || |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
695 mode == ZeroBasedNarrowOop || |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
696 mode == HeapBasedNarrowOop, "mode is invalid"); |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
697 const size_t total_size = heap_size + heap_base_min_address_aligned; |
922
1a81ea4b45d4
6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop")
kvn
parents:
845
diff
changeset
|
698 // Return specified base for the first request. |
1a81ea4b45d4
6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop")
kvn
parents:
845
diff
changeset
|
699 if (!FLAG_IS_DEFAULT(HeapBaseMinAddress) && (mode == UnscaledNarrowOop)) { |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
700 base = heap_base_min_address_aligned; |
7982
10d5f25a7c67
8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops
hseigel
parents:
7623
diff
changeset
|
701 |
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
702 // If the total size is small enough to allow UnscaledNarrowOop then |
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
703 // just use UnscaledNarrowOop. |
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
704 } else if ((total_size <= OopEncodingHeapMax) && (mode != HeapBasedNarrowOop)) { |
7982
10d5f25a7c67
8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops
hseigel
parents:
7623
diff
changeset
|
705 if ((total_size <= NarrowOopHeapMax) && (mode == UnscaledNarrowOop) && |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
706 (Universe::narrow_oop_shift() == 0)) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
707 // Use 32-bits oops without encoding and |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
708 // place heap's top on the 4Gb boundary |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
709 base = (NarrowOopHeapMax - heap_size); |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
710 } else { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
711 // Can't reserve with NarrowOopShift == 0 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
712 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
713 if (mode == UnscaledNarrowOop || |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
714 mode == ZeroBasedNarrowOop && total_size <= NarrowOopHeapMax) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
715 // Use zero based compressed oops with encoding and |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
716 // place heap's top on the 32Gb boundary in case |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
717 // total_size > 4Gb or failed to reserve below 4Gb. |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
718 base = (OopEncodingHeapMax - heap_size); |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
719 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
720 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
721 } else { |
7982
10d5f25a7c67
8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops
hseigel
parents:
7623
diff
changeset
|
722 // UnscaledNarrowOop encoding didn't work, and no base was found for ZeroBasedOops or |
10d5f25a7c67
8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops
hseigel
parents:
7623
diff
changeset
|
723 // HeapBasedNarrowOop encoding was requested. So, can't reserve below 32Gb. |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
724 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
725 } |
7982
10d5f25a7c67
8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops
hseigel
parents:
7623
diff
changeset
|
726 |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
727 // Set narrow_oop_base and narrow_oop_use_implicit_null_checks |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
728 // used in ReservedHeapSpace() constructors. |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
729 // The final values will be set in initialize_heap() below. |
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
730 if ((base != 0) && ((base + heap_size) <= OopEncodingHeapMax)) { |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
731 // Use zero based compressed oops |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
732 Universe::set_narrow_oop_base(NULL); |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
733 // Don't need guard page for implicit checks in indexed |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
734 // addressing mode with zero based Compressed Oops. |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
735 Universe::set_narrow_oop_use_implicit_null_checks(true); |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
736 } else { |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
737 // Set to a non-NULL value so the ReservedSpace ctor computes |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
738 // the correct no-access prefix. |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
739 // The final value will be set in initialize_heap() below. |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
740 Universe::set_narrow_oop_base((address)NarrowOopHeapMax); |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
741 #ifdef _WIN64 |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
742 if (UseLargePages) { |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
743 // Cannot allocate guard pages for implicit checks in indexed |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
744 // addressing mode when large pages are specified on windows. |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
745 Universe::set_narrow_oop_use_implicit_null_checks(false); |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
746 } |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
747 #endif // _WIN64 |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
748 } |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
749 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
750 #endif |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
751 |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
752 assert(is_ptr_aligned((char*)base, alignment), "Must be"); |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
753 return (char*)base; // also return NULL (don't care) for 32-bit VM |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
754 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
755 |
0 | 756 jint Universe::initialize_heap() { |
757 | |
758 if (UseParallelGC) { | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
759 #if INCLUDE_ALL_GCS |
0 | 760 Universe::_collectedHeap = new ParallelScavengeHeap(); |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
761 #else // INCLUDE_ALL_GCS |
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6751
diff
changeset
|
762 fatal("UseParallelGC not supported in this VM."); |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
763 #endif // INCLUDE_ALL_GCS |
0 | 764 |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
765 } else if (UseG1GC) { |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
766 #if INCLUDE_ALL_GCS |
4013 | 767 G1CollectorPolicy* g1p = new G1CollectorPolicy(); |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
768 G1CollectedHeap* g1h = new G1CollectedHeap(g1p); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
769 Universe::_collectedHeap = g1h; |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
770 #else // INCLUDE_ALL_GCS |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
771 fatal("UseG1GC not supported in java kernel vm."); |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
772 #endif // INCLUDE_ALL_GCS |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
773 |
0 | 774 } else { |
775 GenCollectorPolicy *gc_policy; | |
776 | |
777 if (UseSerialGC) { | |
778 gc_policy = new MarkSweepPolicy(); | |
779 } else if (UseConcMarkSweepGC) { | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
780 #if INCLUDE_ALL_GCS |
0 | 781 if (UseAdaptiveSizePolicy) { |
782 gc_policy = new ASConcurrentMarkSweepPolicy(); | |
783 } else { | |
784 gc_policy = new ConcurrentMarkSweepPolicy(); | |
785 } | |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
786 #else // INCLUDE_ALL_GCS |
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6751
diff
changeset
|
787 fatal("UseConcMarkSweepGC not supported in this VM."); |
8001
db9981fd3124
8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents:
7187
diff
changeset
|
788 #endif // INCLUDE_ALL_GCS |
0 | 789 } else { // default old generation |
790 gc_policy = new MarkSweepPolicy(); | |
791 } | |
792 | |
793 Universe::_collectedHeap = new GenCollectedHeap(gc_policy); | |
794 } | |
795 | |
796 jint status = Universe::heap()->initialize(); | |
797 if (status != JNI_OK) { | |
798 return status; | |
799 } | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
800 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
801 #ifdef _LP64 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
802 if (UseCompressedOops) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
803 // Subtract a page because something can get allocated at heap base. |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
804 // This also makes implicit null checking work, because the |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
805 // memory+1 page below heap_base needs to cause a signal. |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
806 // See needs_explicit_null_check. |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
807 // Only set the heap base for compressed oops because it indicates |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
808 // compressed oops for pstack code. |
2080 | 809 bool verbose = PrintCompressedOopsMode || (PrintMiscellaneous && Verbose); |
810 if (verbose) { | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
811 tty->cr(); |
1963 | 812 tty->print("heap address: " PTR_FORMAT ", size: " SIZE_FORMAT " MB", |
813 Universe::heap()->base(), Universe::heap()->reserved_region().byte_size()/M); | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
814 } |
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
815 if (((uint64_t)Universe::heap()->reserved_region().end() > OopEncodingHeapMax)) { |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
816 // Can't reserve heap below 32Gb. |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
817 // keep the Universe::narrow_oop_base() set in Universe::reserve_heap() |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
818 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes); |
2080 | 819 if (verbose) { |
10405 | 820 tty->print(", %s: "PTR_FORMAT, |
821 narrow_oop_mode_to_string(HeapBasedNarrowOop), | |
822 Universe::narrow_oop_base()); | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
823 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
824 } else { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
825 Universe::set_narrow_oop_base(0); |
2080 | 826 if (verbose) { |
10405 | 827 tty->print(", %s", narrow_oop_mode_to_string(ZeroBasedNarrowOop)); |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
828 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
829 #ifdef _WIN64 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
830 if (!Universe::narrow_oop_use_implicit_null_checks()) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
831 // Don't need guard page for implicit checks in indexed addressing |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
832 // mode with zero based Compressed Oops. |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
833 Universe::set_narrow_oop_use_implicit_null_checks(true); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
834 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
835 #endif // _WIN64 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
836 if((uint64_t)Universe::heap()->reserved_region().end() > NarrowOopHeapMax) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
837 // Can't reserve heap below 4Gb. |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
838 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
839 } else { |
922
1a81ea4b45d4
6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop")
kvn
parents:
845
diff
changeset
|
840 Universe::set_narrow_oop_shift(0); |
2080 | 841 if (verbose) { |
10405 | 842 tty->print(", %s", narrow_oop_mode_to_string(UnscaledNarrowOop)); |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
843 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
844 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
845 } |
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
846 |
2080 | 847 if (verbose) { |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
848 tty->cr(); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
849 tty->cr(); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
850 } |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
851 Universe::set_narrow_ptrs_base(Universe::narrow_oop_base()); |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
852 } |
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
853 // Universe::narrow_oop_base() is one page below the heap. |
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
854 assert((intptr_t)Universe::narrow_oop_base() <= (intptr_t)(Universe::heap()->base() - |
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
855 os::vm_page_size()) || |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
856 Universe::narrow_oop_base() == NULL, "invalid value"); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
857 assert(Universe::narrow_oop_shift() == LogMinObjAlignmentInBytes || |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
858 Universe::narrow_oop_shift() == 0, "invalid value"); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
859 #endif |
0 | 860 |
861 // We will never reach the CATCH below since Exceptions::_throw will cause | |
862 // the VM to exit if an exception is thrown during initialization | |
863 | |
864 if (UseTLAB) { | |
865 assert(Universe::heap()->supports_tlab_allocation(), | |
866 "Should support thread-local allocation buffers"); | |
867 ThreadLocalAllocBuffer::startup_initialization(); | |
868 } | |
869 return JNI_OK; | |
870 } | |
871 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
872 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
873 // Reserve the Java heap, which is now the same for all GCs. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
874 ReservedSpace Universe::reserve_heap(size_t heap_size, size_t alignment) { |
12233
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
875 assert(alignment <= Arguments::conservative_max_heap_alignment(), |
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
876 err_msg("actual alignment "SIZE_FORMAT" must be within maximum heap alignment "SIZE_FORMAT, |
40136aa2cdb1
8010722: assert: failed: heap size is too big for compressed oops
tschatzl
parents:
12226
diff
changeset
|
877 alignment, Arguments::conservative_max_heap_alignment())); |
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
878 size_t total_reserved = align_size_up(heap_size, alignment); |
8741
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8003
diff
changeset
|
879 assert(!UseCompressedOops || (total_reserved <= (OopEncodingHeapMax - os::vm_page_size())), |
eac371996b44
8001049: VM crashes when running with large -Xms and not specifying ObjectAlignmentInBytes
brutisso
parents:
8003
diff
changeset
|
880 "heap size is too big for compressed oops"); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
881 |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
882 bool use_large_pages = UseLargePages && is_size_aligned(alignment, os::large_page_size()); |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
883 assert(!UseLargePages |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
884 || UseParallelOldGC |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
885 || use_large_pages, "Wrong alignment to use large pages"); |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
886 |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
887 char* addr = Universe::preferred_heap_base(total_reserved, alignment, Universe::UnscaledNarrowOop); |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
888 |
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
889 ReservedHeapSpace total_rs(total_reserved, alignment, use_large_pages, addr); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
890 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
891 if (UseCompressedOops) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
892 if (addr != NULL && !total_rs.is_reserved()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
893 // Failed to reserve at specified address - the requested memory |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
894 // region is taken already, for example, by 'java' launcher. |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
895 // Try again to reserver heap higher. |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
896 addr = Universe::preferred_heap_base(total_reserved, alignment, Universe::ZeroBasedNarrowOop); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
897 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
898 ReservedHeapSpace total_rs0(total_reserved, alignment, |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
899 use_large_pages, addr); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
900 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
901 if (addr != NULL && !total_rs0.is_reserved()) { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
902 // Failed to reserve at specified address again - give up. |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
903 addr = Universe::preferred_heap_base(total_reserved, alignment, Universe::HeapBasedNarrowOop); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
904 assert(addr == NULL, ""); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
905 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
906 ReservedHeapSpace total_rs1(total_reserved, alignment, |
12110
4c84d351cca9
8007074: SIGSEGV at ParMarkBitMap::verify_clear()
stefank
parents:
12063
diff
changeset
|
907 use_large_pages, addr); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
908 total_rs = total_rs1; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
909 } else { |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
910 total_rs = total_rs0; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
911 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
912 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
913 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
914 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
915 if (!total_rs.is_reserved()) { |
10358
0def34ab1c98
8015007: Incorrect print format in error message for VM cannot allocate the requested heap
tamao
parents:
10265
diff
changeset
|
916 vm_exit_during_initialization(err_msg("Could not reserve enough space for " SIZE_FORMAT "KB object heap", total_reserved/K)); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
917 return total_rs; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
918 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
919 |
6848
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
920 if (UseCompressedOops) { |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
921 // Universe::initialize_heap() will reset this to NULL if unscaled |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
922 // or zero-based narrow oops are actually used. |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
923 address base = (address)(total_rs.base() - os::vm_page_size()); |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
924 Universe::set_narrow_oop_base(base); |
8e47bac5643a
7054512: Compress class pointers after perm gen removal
roland
parents:
6751
diff
changeset
|
925 } |
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
926 return total_rs; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
927 } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
928 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
929 |
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
12022
diff
changeset
|
930 // It's the caller's responsibility to ensure glitch-freedom |
0 | 931 // (if required). |
932 void Universe::update_heap_info_at_gc() { | |
933 _heap_capacity_at_last_gc = heap()->capacity(); | |
934 _heap_used_at_last_gc = heap()->used(); | |
935 } | |
936 | |
937 | |
10405 | 938 const char* Universe::narrow_oop_mode_to_string(Universe::NARROW_OOP_MODE mode) { |
939 switch (mode) { | |
940 case UnscaledNarrowOop: | |
941 return "32-bits Oops"; | |
942 case ZeroBasedNarrowOop: | |
943 return "zero based Compressed Oops"; | |
944 case HeapBasedNarrowOop: | |
945 return "Compressed Oops with base"; | |
946 } | |
947 | |
948 ShouldNotReachHere(); | |
949 return ""; | |
950 } | |
951 | |
952 | |
953 Universe::NARROW_OOP_MODE Universe::narrow_oop_mode() { | |
954 if (narrow_oop_base() != 0) { | |
955 return HeapBasedNarrowOop; | |
956 } | |
957 | |
958 if (narrow_oop_shift() != 0) { | |
959 return ZeroBasedNarrowOop; | |
960 } | |
961 | |
962 return UnscaledNarrowOop; | |
963 } | |
964 | |
0 | 965 |
966 void universe2_init() { | |
967 EXCEPTION_MARK; | |
968 Universe::genesis(CATCH); | |
969 } | |
970 | |
971 | |
972 // This function is defined in JVM.cpp | |
973 extern void initialize_converter_functions(); | |
974 | |
975 bool universe_post_init() { | |
1959
9eecf81a02fb
7000578: CMS: assert(SafepointSynchronize::is_at_safepoint()) failed: Else races are possible
ysr
parents:
1579
diff
changeset
|
976 assert(!is_init_completed(), "Error: initialization not yet completed!"); |
0 | 977 Universe::_fully_initialized = true; |
978 EXCEPTION_MARK; | |
979 { ResourceMark rm; | |
980 Interpreter::initialize(); // needed for interpreter entry points | |
981 if (!UseSharedSpaces) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
982 HandleMark hm(THREAD); |
1142 | 983 KlassHandle ok_h(THREAD, SystemDictionary::Object_klass()); |
0 | 984 Universe::reinitialize_vtable_of(ok_h, CHECK_false); |
985 Universe::reinitialize_itables(CHECK_false); | |
986 } | |
987 } | |
988 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
989 HandleMark hm(THREAD); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
990 Klass* k; |
0 | 991 instanceKlassHandle k_h; |
992 // Setup preallocated empty java.lang.Class array | |
1142 | 993 Universe::_the_empty_class_klass_array = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_false); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
994 |
0 | 995 // Setup preallocated OutOfMemoryError errors |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
996 k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_OutOfMemoryError(), true, CHECK_false); |
0 | 997 k_h = instanceKlassHandle(THREAD, k); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
998 Universe::_out_of_memory_error_java_heap = k_h->allocate_instance(CHECK_false); |
11064
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
999 Universe::_out_of_memory_error_metaspace = k_h->allocate_instance(CHECK_false); |
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
1000 Universe::_out_of_memory_error_class_metaspace = k_h->allocate_instance(CHECK_false); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1001 Universe::_out_of_memory_error_array_size = k_h->allocate_instance(CHECK_false); |
0 | 1002 Universe::_out_of_memory_error_gc_overhead_limit = |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1003 k_h->allocate_instance(CHECK_false); |
0 | 1004 |
1005 // Setup preallocated NullPointerException | |
1006 // (this is currently used for a cheap & dirty solution in compiler exception handling) | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
1007 k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_NullPointerException(), true, CHECK_false); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1008 Universe::_null_ptr_exception_instance = InstanceKlass::cast(k)->allocate_instance(CHECK_false); |
0 | 1009 // Setup preallocated ArithmeticException |
1010 // (this is currently used for a cheap & dirty solution in compiler exception handling) | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
1011 k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ArithmeticException(), true, CHECK_false); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1012 Universe::_arithmetic_exception_instance = InstanceKlass::cast(k)->allocate_instance(CHECK_false); |
0 | 1013 // Virtual Machine Error for when we get into a situation we can't resolve |
1014 k = SystemDictionary::resolve_or_fail( | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
1015 vmSymbols::java_lang_VirtualMachineError(), true, CHECK_false); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1016 bool linked = InstanceKlass::cast(k)->link_class_or_fail(CHECK_false); |
0 | 1017 if (!linked) { |
1018 tty->print_cr("Unable to link/verify VirtualMachineError class"); | |
1019 return false; // initialization failed | |
1020 } | |
1021 Universe::_virtual_machine_error_instance = | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1022 InstanceKlass::cast(k)->allocate_instance(CHECK_false); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
1023 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1024 Universe::_vm_exception = InstanceKlass::cast(k)->allocate_instance(CHECK_false); |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2080
diff
changeset
|
1025 |
0 | 1026 if (!DumpSharedSpaces) { |
1027 // These are the only Java fields that are currently set during shared space dumping. | |
1028 // We prefer to not handle this generally, so we always reinitialize these detail messages. | |
1029 Handle msg = java_lang_String::create_from_str("Java heap space", CHECK_false); | |
1030 java_lang_Throwable::set_message(Universe::_out_of_memory_error_java_heap, msg()); | |
1031 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1032 msg = java_lang_String::create_from_str("Metadata space", CHECK_false); |
11064
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
1033 java_lang_Throwable::set_message(Universe::_out_of_memory_error_metaspace, msg()); |
12226
7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents:
12110
diff
changeset
|
1034 msg = java_lang_String::create_from_str("Compressed class space", CHECK_false); |
11064
de2d15ce3d4a
8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty
coleenp
parents:
10973
diff
changeset
|
1035 java_lang_Throwable::set_message(Universe::_out_of_memory_error_class_metaspace, msg()); |
0 | 1036 |
1037 msg = java_lang_String::create_from_str("Requested array size exceeds VM limit", CHECK_false); | |
1038 java_lang_Throwable::set_message(Universe::_out_of_memory_error_array_size, msg()); | |
1039 | |
1040 msg = java_lang_String::create_from_str("GC overhead limit exceeded", CHECK_false); | |
1041 java_lang_Throwable::set_message(Universe::_out_of_memory_error_gc_overhead_limit, msg()); | |
1042 | |
1043 msg = java_lang_String::create_from_str("/ by zero", CHECK_false); | |
1044 java_lang_Throwable::set_message(Universe::_arithmetic_exception_instance, msg()); | |
1045 | |
1046 // Setup the array of errors that have preallocated backtrace | |
1047 k = Universe::_out_of_memory_error_java_heap->klass(); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1048 assert(k->name() == vmSymbols::java_lang_OutOfMemoryError(), "should be out of memory error"); |
0 | 1049 k_h = instanceKlassHandle(THREAD, k); |
1050 | |
1051 int len = (StackTraceInThrowable) ? (int)PreallocatedOutOfMemoryErrorCount : 0; | |
1052 Universe::_preallocated_out_of_memory_error_array = oopFactory::new_objArray(k_h(), len, CHECK_false); | |
1053 for (int i=0; i<len; i++) { | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1054 oop err = k_h->allocate_instance(CHECK_false); |
0 | 1055 Handle err_h = Handle(THREAD, err); |
1056 java_lang_Throwable::allocate_backtrace(err_h, CHECK_false); | |
1057 Universe::preallocated_out_of_memory_errors()->obj_at_put(i, err_h()); | |
1058 } | |
1059 Universe::_preallocated_out_of_memory_error_avail_count = (jint)len; | |
1060 } | |
1061 | |
1062 | |
1063 // Setup static method for registering finalizers | |
1064 // The finalizer klass must be linked before looking up the method, in | |
1065 // case it needs to get rewritten. | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1066 InstanceKlass::cast(SystemDictionary::Finalizer_klass())->link_class(CHECK_false); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1067 Method* m = InstanceKlass::cast(SystemDictionary::Finalizer_klass())->find_method( |
0 | 1068 vmSymbols::register_method_name(), |
1069 vmSymbols::register_method_signature()); | |
1070 if (m == NULL || !m->is_static()) { | |
12022
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
1071 tty->print_cr("Unable to link/verify Finalizer.register method"); |
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
1072 return false; // initialization failed (cannot throw exception yet) |
0 | 1073 } |
1074 Universe::_finalizer_register_cache->init( | |
12022
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
1075 SystemDictionary::Finalizer_klass(), m); |
0 | 1076 |
6751
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6736
diff
changeset
|
1077 // Setup method for registering loaded classes in class loader vector |
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6736
diff
changeset
|
1078 InstanceKlass::cast(SystemDictionary::ClassLoader_klass())->link_class(CHECK_false); |
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6736
diff
changeset
|
1079 m = InstanceKlass::cast(SystemDictionary::ClassLoader_klass())->find_method(vmSymbols::addClass_name(), vmSymbols::class_void_signature()); |
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6736
diff
changeset
|
1080 if (m == NULL || m->is_static()) { |
12022
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
1081 tty->print_cr("Unable to link/verify ClassLoader.addClass method"); |
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
1082 return false; // initialization failed (cannot throw exception yet) |
6751
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6736
diff
changeset
|
1083 } |
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6736
diff
changeset
|
1084 Universe::_loader_addClass_cache->init( |
12022
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
1085 SystemDictionary::ClassLoader_klass(), m); |
6751
2a48c84f1d04
7197269: NPG: FollowReferences has no ClassLoader -> Class link to follow
coleenp
parents:
6736
diff
changeset
|
1086 |
11010 | 1087 // Setup method for checking protection domain |
1088 InstanceKlass::cast(SystemDictionary::ProtectionDomain_klass())->link_class(CHECK_false); | |
1089 m = InstanceKlass::cast(SystemDictionary::ProtectionDomain_klass())-> | |
1090 find_method(vmSymbols::impliesCreateAccessControlContext_name(), | |
1091 vmSymbols::void_boolean_signature()); | |
1092 // Allow NULL which should only happen with bootstrapping. | |
1093 if (m != NULL) { | |
1094 if (m->is_static()) { | |
1095 // NoSuchMethodException doesn't actually work because it tries to run the | |
1096 // <init> function before java_lang_Class is linked. Print error and exit. | |
1097 tty->print_cr("ProtectionDomain.impliesCreateAccessControlContext() has the wrong linkage"); | |
1098 return false; // initialization failed | |
1099 } | |
1100 Universe::_pd_implies_cache->init( | |
12022
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
1101 SystemDictionary::ProtectionDomain_klass(), m);; |
11010 | 1102 } |
1103 | |
0 | 1104 // The folowing is initializing converter functions for serialization in |
1105 // JVM.cpp. If we clean up the StrictMath code above we may want to find | |
1106 // a better solution for this as well. | |
1107 initialize_converter_functions(); | |
1108 | |
1109 // This needs to be done before the first scavenge/gc, since | |
1110 // it's an input to soft ref clearing policy. | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1111 { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1112 MutexLocker x(Heap_lock); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1113 Universe::update_heap_info_at_gc(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1114 } |
0 | 1115 |
1116 // ("weak") refs processing infrastructure initialization | |
1117 Universe::heap()->post_initialize(); | |
1118 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1119 // Initialize performance counters for metaspaces |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1120 MetaspaceCounters::initialize_performance_counters(); |
12063
1a8fb39bdbc4
8014659: NPG: performance counters for compressed klass space
ehelin
parents:
12056
diff
changeset
|
1121 CompressedClassSpaceCounters::initialize_performance_counters(); |
1a8fb39bdbc4
8014659: NPG: performance counters for compressed klass space
ehelin
parents:
12056
diff
changeset
|
1122 |
11039
71963b3f802a
8013590: NPG: Add a memory pool MXBean for Metaspace
ehelin
parents:
10973
diff
changeset
|
1123 MemoryService::add_metaspace_memory_pools(); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1124 |
0 | 1125 GC_locker::unlock(); // allow gc after bootstrapping |
1126 | |
1127 MemoryService::set_universe_heap(Universe::_collectedHeap); | |
1128 return true; | |
1129 } | |
1130 | |
1131 | |
1132 void Universe::compute_base_vtable_size() { | |
1133 _base_vtable_size = ClassLoader::compute_Object_vtable(); | |
1134 } | |
1135 | |
1136 | |
1137 // %%% The Universe::flush_foo methods belong in CodeCache. | |
1138 | |
1139 // Flushes compiled methods dependent on dependee. | |
1140 void Universe::flush_dependents_on(instanceKlassHandle dependee) { | |
1141 assert_lock_strong(Compile_lock); | |
1142 | |
1143 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return; | |
1144 | |
1145 // CodeCache can only be updated by a thread_in_VM and they will all be | |
1146 // stopped dring the safepoint so CodeCache will be safe to update without | |
1147 // holding the CodeCache_lock. | |
1148 | |
3852
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1149 KlassDepChange changes(dependee); |
0 | 1150 |
1151 // Compute the dependent nmethods | |
1152 if (CodeCache::mark_for_deoptimization(changes) > 0) { | |
1153 // At least one nmethod has been marked for deoptimization | |
1154 VM_Deoptimize op; | |
1155 VMThread::execute(&op); | |
1156 } | |
1157 } | |
1158 | |
3852
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1159 // Flushes compiled methods dependent on a particular CallSite |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1160 // instance when its target is different than the given MethodHandle. |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1161 void Universe::flush_dependents_on(Handle call_site, Handle method_handle) { |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1162 assert_lock_strong(Compile_lock); |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1163 |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1164 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return; |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1165 |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1166 // CodeCache can only be updated by a thread_in_VM and they will all be |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1167 // stopped dring the safepoint so CodeCache will be safe to update without |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1168 // holding the CodeCache_lock. |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1169 |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1170 CallSiteDepChange changes(call_site(), method_handle()); |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1171 |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1172 // Compute the dependent nmethods that have a reference to a |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1173 // CallSite object. We use InstanceKlass::mark_dependent_nmethod |
3852
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1174 // directly instead of CodeCache::mark_for_deoptimization because we |
3894
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3852
diff
changeset
|
1175 // want dependents on the call site class only not all classes in |
b27c72d69fd1
7083184: JSR 292: don't store context class argument with call site dependencies
twisti
parents:
3852
diff
changeset
|
1176 // the ContextStream. |
3852
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1177 int marked = 0; |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1178 { |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1179 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1180 InstanceKlass* call_site_klass = InstanceKlass::cast(call_site->klass()); |
3852
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1181 marked = call_site_klass->mark_dependent_nmethods(changes); |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1182 } |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1183 if (marked > 0) { |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1184 // At least one nmethod has been marked for deoptimization |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1185 VM_Deoptimize op; |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1186 VMThread::execute(&op); |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1187 } |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1188 } |
fdb992d83a87
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
3772
diff
changeset
|
1189 |
0 | 1190 #ifdef HOTSWAP |
1191 // Flushes compiled methods dependent on dependee in the evolutionary sense | |
1192 void Universe::flush_evol_dependents_on(instanceKlassHandle ev_k_h) { | |
1193 // --- Compile_lock is not held. However we are at a safepoint. | |
1194 assert_locked_or_safepoint(Compile_lock); | |
1195 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return; | |
1196 | |
1197 // CodeCache can only be updated by a thread_in_VM and they will all be | |
1198 // stopped dring the safepoint so CodeCache will be safe to update without | |
1199 // holding the CodeCache_lock. | |
1200 | |
1201 // Compute the dependent nmethods | |
1202 if (CodeCache::mark_for_evol_deoptimization(ev_k_h) > 0) { | |
1203 // At least one nmethod has been marked for deoptimization | |
1204 | |
1205 // All this already happens inside a VM_Operation, so we'll do all the work here. | |
1206 // Stuff copied from VM_Deoptimize and modified slightly. | |
1207 | |
1208 // We do not want any GCs to happen while we are in the middle of this VM operation | |
1209 ResourceMark rm; | |
1210 DeoptimizationMarker dm; | |
1211 | |
1212 // Deoptimize all activations depending on marked nmethods | |
1213 Deoptimization::deoptimize_dependents(); | |
1214 | |
1215 // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies) | |
1216 CodeCache::make_marked_nmethods_not_entrant(); | |
1217 } | |
1218 } | |
1219 #endif // HOTSWAP | |
1220 | |
1221 | |
1222 // Flushes compiled methods dependent on dependee | |
1223 void Universe::flush_dependents_on_method(methodHandle m_h) { | |
1224 // --- Compile_lock is not held. However we are at a safepoint. | |
1225 assert_locked_or_safepoint(Compile_lock); | |
1226 | |
1227 // CodeCache can only be updated by a thread_in_VM and they will all be | |
1228 // stopped dring the safepoint so CodeCache will be safe to update without | |
1229 // holding the CodeCache_lock. | |
1230 | |
1231 // Compute the dependent nmethods | |
1232 if (CodeCache::mark_for_deoptimization(m_h()) > 0) { | |
1233 // At least one nmethod has been marked for deoptimization | |
1234 | |
1235 // All this already happens inside a VM_Operation, so we'll do all the work here. | |
1236 // Stuff copied from VM_Deoptimize and modified slightly. | |
1237 | |
1238 // We do not want any GCs to happen while we are in the middle of this VM operation | |
1239 ResourceMark rm; | |
1240 DeoptimizationMarker dm; | |
1241 | |
1242 // Deoptimize all activations depending on marked nmethods | |
1243 Deoptimization::deoptimize_dependents(); | |
1244 | |
1245 // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies) | |
1246 CodeCache::make_marked_nmethods_not_entrant(); | |
1247 } | |
1248 } | |
1249 | |
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1250 void Universe::print() { |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1251 print_on(gclog_or_tty); |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1252 } |
0 | 1253 |
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1254 void Universe::print_on(outputStream* st, bool extended) { |
0 | 1255 st->print_cr("Heap"); |
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1256 if (!extended) { |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1257 heap()->print_on(st); |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1258 } else { |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1259 heap()->print_extended_on(st); |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1260 } |
0 | 1261 } |
1262 | |
1263 void Universe::print_heap_at_SIGBREAK() { | |
1264 if (PrintHeapAtSIGBREAK) { | |
1265 MutexLocker hl(Heap_lock); | |
1266 print_on(tty); | |
1267 tty->cr(); | |
1268 tty->flush(); | |
1269 } | |
1270 } | |
1271 | |
4944 | 1272 void Universe::print_heap_before_gc(outputStream* st, bool ignore_extended) { |
0 | 1273 st->print_cr("{Heap before GC invocations=%u (full %u):", |
1274 heap()->total_collections(), | |
1275 heap()->total_full_collections()); | |
4944 | 1276 if (!PrintHeapAtGCExtended || ignore_extended) { |
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1277 heap()->print_on(st); |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1278 } else { |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1279 heap()->print_extended_on(st); |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1280 } |
0 | 1281 } |
1282 | |
4944 | 1283 void Universe::print_heap_after_gc(outputStream* st, bool ignore_extended) { |
0 | 1284 st->print_cr("Heap after GC invocations=%u (full %u):", |
1285 heap()->total_collections(), | |
1286 heap()->total_full_collections()); | |
4944 | 1287 if (!PrintHeapAtGCExtended || ignore_extended) { |
4073
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1288 heap()->print_on(st); |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1289 } else { |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1290 heap()->print_extended_on(st); |
53074c2c4600
7099849: G1: include heap region information in hs_err files
tonyp
parents:
4013
diff
changeset
|
1291 } |
0 | 1292 st->print_cr("}"); |
1293 } | |
1294 | |
10186
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
9062
diff
changeset
|
1295 void Universe::verify(VerifyOption option, const char* prefix, bool silent) { |
0 | 1296 // The use of _verify_in_progress is a temporary work around for |
1297 // 6320749. Don't bother with a creating a class to set and clear | |
1298 // it since it is only used in this method and the control flow is | |
1299 // straight forward. | |
1300 _verify_in_progress = true; | |
1301 | |
1302 COMPILER2_PRESENT( | |
1303 assert(!DerivedPointerTable::is_active(), | |
1304 "DPT should not be active during verification " | |
1305 "(of thread stacks below)"); | |
1306 ) | |
1307 | |
1308 ResourceMark rm; | |
1309 HandleMark hm; // Handles created during verification can be zapped | |
1310 _verify_count++; | |
1311 | |
10186
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
9062
diff
changeset
|
1312 if (!silent) gclog_or_tty->print(prefix); |
0 | 1313 if (!silent) gclog_or_tty->print("[Verifying "); |
1314 if (!silent) gclog_or_tty->print("threads "); | |
1315 Threads::verify(); | |
10186
b06ac540229e
8013132: Add a flag to turn off the output of the verbose verification code
stefank
parents:
9062
diff
changeset
|
1316 if (!silent) gclog_or_tty->print("heap "); |
6008 | 1317 heap()->verify(silent, option); |
0 | 1318 if (!silent) gclog_or_tty->print("syms "); |
1319 SymbolTable::verify(); | |
1320 if (!silent) gclog_or_tty->print("strs "); | |
1321 StringTable::verify(); | |
1322 { | |
1323 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
1324 if (!silent) gclog_or_tty->print("zone "); | |
1325 CodeCache::verify(); | |
1326 } | |
1327 if (!silent) gclog_or_tty->print("dict "); | |
1328 SystemDictionary::verify(); | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1329 #ifndef PRODUCT |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1330 if (!silent) gclog_or_tty->print("cldg "); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1331 ClassLoaderDataGraph::verify(); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1332 #endif |
6969
6bc207d87e5d
7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java
mgerdin
parents:
6870
diff
changeset
|
1333 if (!silent) gclog_or_tty->print("metaspace chunks "); |
6bc207d87e5d
7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java
mgerdin
parents:
6870
diff
changeset
|
1334 MetaspaceAux::verify_free_chunks(); |
0 | 1335 if (!silent) gclog_or_tty->print("hand "); |
1336 JNIHandles::verify(); | |
1337 if (!silent) gclog_or_tty->print("C-heap "); | |
1338 os::check_heap(); | |
2375
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2177
diff
changeset
|
1339 if (!silent) gclog_or_tty->print("code cache "); |
d673ef06fe96
7028374: race in fix_oop_relocations for scavengeable nmethods
never
parents:
2177
diff
changeset
|
1340 CodeCache::verify_oops(); |
0 | 1341 if (!silent) gclog_or_tty->print_cr("]"); |
1342 | |
1343 _verify_in_progress = false; | |
1344 } | |
1345 | |
1346 // Oop verification (see MacroAssembler::verify_oop) | |
1347 | |
1348 static uintptr_t _verify_oop_data[2] = {0, (uintptr_t)-1}; | |
1349 static uintptr_t _verify_klass_data[2] = {0, (uintptr_t)-1}; | |
1350 | |
1351 | |
9060
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
8827
diff
changeset
|
1352 #ifndef PRODUCT |
cc32ccaaf47f
8003310: Enable -Wunused-function when compiling with gcc
mikael
parents:
8827
diff
changeset
|
1353 |
0 | 1354 static void calculate_verify_data(uintptr_t verify_data[2], |
1355 HeapWord* low_boundary, | |
1356 HeapWord* high_boundary) { | |
1357 assert(low_boundary < high_boundary, "bad interval"); | |
1358 | |
1359 // decide which low-order bits we require to be clear: | |
1360 size_t alignSize = MinObjAlignmentInBytes; | |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1507
diff
changeset
|
1361 size_t min_object_size = CollectedHeap::min_fill_size(); |
0 | 1362 |
1363 // make an inclusive limit: | |
1364 uintptr_t max = (uintptr_t)high_boundary - min_object_size*wordSize; | |
1365 uintptr_t min = (uintptr_t)low_boundary; | |
1366 assert(min < max, "bad interval"); | |
1367 uintptr_t diff = max ^ min; | |
1368 | |
1369 // throw away enough low-order bits to make the diff vanish | |
1370 uintptr_t mask = (uintptr_t)(-1); | |
1371 while ((mask & diff) != 0) | |
1372 mask <<= 1; | |
1373 uintptr_t bits = (min & mask); | |
1374 assert(bits == (max & mask), "correct mask"); | |
1375 // check an intermediate value between min and max, just to make sure: | |
1376 assert(bits == ((min + (max-min)/2) & mask), "correct mask"); | |
1377 | |
1378 // require address alignment, too: | |
1379 mask |= (alignSize - 1); | |
1380 | |
1381 if (!(verify_data[0] == 0 && verify_data[1] == (uintptr_t)-1)) { | |
1382 assert(verify_data[0] == mask && verify_data[1] == bits, "mask stability"); | |
1383 } | |
1384 verify_data[0] = mask; | |
1385 verify_data[1] = bits; | |
1386 } | |
1387 | |
1388 // Oop verification (see MacroAssembler::verify_oop) | |
1389 | |
1390 uintptr_t Universe::verify_oop_mask() { | |
1391 MemRegion m = heap()->reserved_region(); | |
1392 calculate_verify_data(_verify_oop_data, | |
1393 m.start(), | |
1394 m.end()); | |
1395 return _verify_oop_data[0]; | |
1396 } | |
1397 | |
1398 | |
1399 | |
1400 uintptr_t Universe::verify_oop_bits() { | |
1401 verify_oop_mask(); | |
1402 return _verify_oop_data[1]; | |
1403 } | |
1404 | |
1405 uintptr_t Universe::verify_mark_mask() { | |
1406 return markOopDesc::lock_mask_in_place; | |
1407 } | |
1408 | |
1409 uintptr_t Universe::verify_mark_bits() { | |
1410 intptr_t mask = verify_mark_mask(); | |
1411 intptr_t bits = (intptr_t)markOopDesc::prototype(); | |
1412 assert((bits & ~mask) == 0, "no stray header bits"); | |
1413 return bits; | |
1414 } | |
1415 #endif // PRODUCT | |
1416 | |
1417 | |
1418 void Universe::compute_verify_oop_data() { | |
1419 verify_oop_mask(); | |
1420 verify_oop_bits(); | |
1421 verify_mark_mask(); | |
1422 verify_mark_bits(); | |
1423 } | |
1424 | |
1425 | |
12022
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
1426 void LatestMethodCache::init(Klass* k, Method* m) { |
0 | 1427 if (!UseSharedSpaces) { |
1428 _klass = k; | |
1429 } | |
1430 #ifndef PRODUCT | |
1431 else { | |
1432 // sharing initilization should have already set up _klass | |
1433 assert(_klass != NULL, "just checking"); | |
1434 } | |
1435 #endif | |
1436 | |
1437 _method_idnum = m->method_idnum(); | |
1438 assert(_method_idnum >= 0, "sanity check"); | |
1439 } | |
1440 | |
1441 | |
12022
85147f28faba
8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32
coleenp
parents:
11096
diff
changeset
|
1442 Method* LatestMethodCache::get_method() { |
11010 | 1443 if (klass() == NULL) return NULL; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1444 InstanceKlass* ik = InstanceKlass::cast(klass()); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
1445 Method* m = ik->method_with_idnum(method_idnum()); |
0 | 1446 assert(m != NULL, "sanity check"); |
1447 return m; | |
1448 } | |
1449 | |
1450 | |
1451 #ifdef ASSERT | |
1452 // Release dummy object(s) at bottom of heap | |
1453 bool Universe::release_fullgc_alot_dummy() { | |
1454 MutexLocker ml(FullGCALot_lock); | |
1455 if (_fullgc_alot_dummy_array != NULL) { | |
1456 if (_fullgc_alot_dummy_next >= _fullgc_alot_dummy_array->length()) { | |
1457 // No more dummies to release, release entire array instead | |
1458 _fullgc_alot_dummy_array = NULL; | |
1459 return false; | |
1460 } | |
1461 if (!UseConcMarkSweepGC) { | |
1462 // Release dummy at bottom of old generation | |
1463 _fullgc_alot_dummy_array->obj_at_put(_fullgc_alot_dummy_next++, NULL); | |
1464 } | |
1465 // Release dummy at bottom of permanent generation | |
1466 _fullgc_alot_dummy_array->obj_at_put(_fullgc_alot_dummy_next++, NULL); | |
1467 } | |
1468 return true; | |
1469 } | |
1470 | |
1471 #endif // ASSERT |