Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/universe.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
author | ysr |
---|---|
date | Tue, 07 Dec 2010 21:55:53 -0800 |
parents | f95d63e2154a |
children | c04052fd6ae1 |
rev | line source |
---|---|
0 | 1 /* |
1972 | 2 * Copyright (c) 1997, 2010, 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" | |
27 #include "classfile/javaClasses.hpp" | |
28 #include "classfile/symbolTable.hpp" | |
29 #include "classfile/systemDictionary.hpp" | |
30 #include "classfile/vmSymbols.hpp" | |
31 #include "code/codeCache.hpp" | |
32 #include "code/dependencies.hpp" | |
33 #include "gc_interface/collectedHeap.inline.hpp" | |
34 #include "interpreter/interpreter.hpp" | |
35 #include "memory/cardTableModRefBS.hpp" | |
36 #include "memory/filemap.hpp" | |
37 #include "memory/gcLocker.inline.hpp" | |
38 #include "memory/genCollectedHeap.hpp" | |
39 #include "memory/genRemSet.hpp" | |
40 #include "memory/generation.hpp" | |
41 #include "memory/oopFactory.hpp" | |
42 #include "memory/permGen.hpp" | |
43 #include "memory/space.hpp" | |
44 #include "memory/universe.hpp" | |
45 #include "memory/universe.inline.hpp" | |
46 #include "oops/arrayKlassKlass.hpp" | |
47 #include "oops/compiledICHolderKlass.hpp" | |
48 #include "oops/constMethodKlass.hpp" | |
49 #include "oops/constantPoolKlass.hpp" | |
50 #include "oops/constantPoolOop.hpp" | |
51 #include "oops/cpCacheKlass.hpp" | |
52 #include "oops/cpCacheOop.hpp" | |
53 #include "oops/instanceKlass.hpp" | |
54 #include "oops/instanceKlassKlass.hpp" | |
55 #include "oops/instanceRefKlass.hpp" | |
56 #include "oops/klassKlass.hpp" | |
57 #include "oops/klassOop.hpp" | |
58 #include "oops/methodDataKlass.hpp" | |
59 #include "oops/methodKlass.hpp" | |
60 #include "oops/objArrayKlassKlass.hpp" | |
61 #include "oops/oop.inline.hpp" | |
62 #include "oops/symbolKlass.hpp" | |
63 #include "oops/typeArrayKlass.hpp" | |
64 #include "oops/typeArrayKlassKlass.hpp" | |
65 #include "prims/jvmtiRedefineClassesTrace.hpp" | |
66 #include "runtime/aprofiler.hpp" | |
67 #include "runtime/arguments.hpp" | |
68 #include "runtime/deoptimization.hpp" | |
69 #include "runtime/fprofiler.hpp" | |
70 #include "runtime/handles.inline.hpp" | |
71 #include "runtime/init.hpp" | |
72 #include "runtime/java.hpp" | |
73 #include "runtime/javaCalls.hpp" | |
74 #include "runtime/sharedRuntime.hpp" | |
75 #include "runtime/synchronizer.hpp" | |
76 #include "runtime/timer.hpp" | |
77 #include "runtime/vm_operations.hpp" | |
78 #include "services/memoryService.hpp" | |
79 #include "utilities/copy.hpp" | |
80 #include "utilities/events.hpp" | |
81 #include "utilities/hashtable.inline.hpp" | |
82 #include "utilities/preserveException.hpp" | |
83 #ifdef TARGET_OS_FAMILY_linux | |
84 # include "thread_linux.inline.hpp" | |
85 #endif | |
86 #ifdef TARGET_OS_FAMILY_solaris | |
87 # include "thread_solaris.inline.hpp" | |
88 #endif | |
89 #ifdef TARGET_OS_FAMILY_windows | |
90 # include "thread_windows.inline.hpp" | |
91 #endif | |
92 #ifndef SERIALGC | |
93 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp" | |
94 #include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp" | |
95 #include "gc_implementation/g1/g1CollectedHeap.inline.hpp" | |
96 #include "gc_implementation/g1/g1CollectorPolicy.hpp" | |
97 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" | |
98 #endif | |
0 | 99 |
100 // Known objects | |
101 klassOop Universe::_boolArrayKlassObj = NULL; | |
102 klassOop Universe::_byteArrayKlassObj = NULL; | |
103 klassOop Universe::_charArrayKlassObj = NULL; | |
104 klassOop Universe::_intArrayKlassObj = NULL; | |
105 klassOop Universe::_shortArrayKlassObj = NULL; | |
106 klassOop Universe::_longArrayKlassObj = NULL; | |
107 klassOop Universe::_singleArrayKlassObj = NULL; | |
108 klassOop Universe::_doubleArrayKlassObj = NULL; | |
109 klassOop Universe::_typeArrayKlassObjs[T_VOID+1] = { NULL /*, NULL...*/ }; | |
110 klassOop Universe::_objectArrayKlassObj = NULL; | |
111 klassOop Universe::_symbolKlassObj = NULL; | |
112 klassOop Universe::_methodKlassObj = NULL; | |
113 klassOop Universe::_constMethodKlassObj = NULL; | |
114 klassOop Universe::_methodDataKlassObj = NULL; | |
115 klassOop Universe::_klassKlassObj = NULL; | |
116 klassOop Universe::_arrayKlassKlassObj = NULL; | |
117 klassOop Universe::_objArrayKlassKlassObj = NULL; | |
118 klassOop Universe::_typeArrayKlassKlassObj = NULL; | |
119 klassOop Universe::_instanceKlassKlassObj = NULL; | |
120 klassOop Universe::_constantPoolKlassObj = NULL; | |
121 klassOop Universe::_constantPoolCacheKlassObj = NULL; | |
122 klassOop Universe::_compiledICHolderKlassObj = NULL; | |
123 klassOop Universe::_systemObjArrayKlassObj = NULL; | |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
124 oop Universe::_int_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
125 oop Universe::_float_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
126 oop Universe::_double_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
127 oop Universe::_byte_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
128 oop Universe::_bool_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
129 oop Universe::_char_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
130 oop Universe::_long_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
131 oop Universe::_short_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
132 oop Universe::_void_mirror = NULL; |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
133 oop Universe::_mirrors[T_VOID+1] = { NULL /*, NULL...*/ }; |
0 | 134 oop Universe::_main_thread_group = NULL; |
135 oop Universe::_system_thread_group = NULL; | |
136 typeArrayOop Universe::_the_empty_byte_array = NULL; | |
137 typeArrayOop Universe::_the_empty_short_array = NULL; | |
138 typeArrayOop Universe::_the_empty_int_array = NULL; | |
139 objArrayOop Universe::_the_empty_system_obj_array = NULL; | |
140 objArrayOop Universe::_the_empty_class_klass_array = NULL; | |
141 objArrayOop Universe::_the_array_interfaces_array = NULL; | |
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
142 oop Universe::_the_null_string = NULL; |
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
143 oop Universe::_the_min_jint_string = NULL; |
0 | 144 LatestMethodOopCache* Universe::_finalizer_register_cache = NULL; |
145 LatestMethodOopCache* Universe::_loader_addClass_cache = NULL; | |
146 ActiveMethodOopsCache* Universe::_reflect_invoke_cache = NULL; | |
147 oop Universe::_out_of_memory_error_java_heap = NULL; | |
148 oop Universe::_out_of_memory_error_perm_gen = NULL; | |
149 oop Universe::_out_of_memory_error_array_size = NULL; | |
150 oop Universe::_out_of_memory_error_gc_overhead_limit = NULL; | |
151 objArrayOop Universe::_preallocated_out_of_memory_error_array = NULL; | |
152 volatile jint Universe::_preallocated_out_of_memory_error_avail_count = 0; | |
153 bool Universe::_verify_in_progress = false; | |
154 oop Universe::_null_ptr_exception_instance = NULL; | |
155 oop Universe::_arithmetic_exception_instance = NULL; | |
156 oop Universe::_virtual_machine_error_instance = NULL; | |
157 oop Universe::_vm_exception = NULL; | |
158 oop Universe::_emptySymbol = NULL; | |
159 | |
160 // These variables are guarded by FullGCALot_lock. | |
161 debug_only(objArrayOop Universe::_fullgc_alot_dummy_array = NULL;) | |
162 debug_only(int Universe::_fullgc_alot_dummy_next = 0;) | |
163 | |
164 | |
165 // Heap | |
166 int Universe::_verify_count = 0; | |
167 | |
168 int Universe::_base_vtable_size = 0; | |
169 bool Universe::_bootstrapping = false; | |
170 bool Universe::_fully_initialized = false; | |
171 | |
172 size_t Universe::_heap_capacity_at_last_gc; | |
453
c96030fff130
6684579: SoftReference processing can be made more efficient
ysr
parents:
356
diff
changeset
|
173 size_t Universe::_heap_used_at_last_gc = 0; |
0 | 174 |
175 CollectedHeap* Universe::_collectedHeap = NULL; | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
176 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
177 NarrowOopStruct Universe::_narrow_oop = { NULL, 0, true }; |
0 | 178 |
179 | |
180 void Universe::basic_type_classes_do(void f(klassOop)) { | |
181 f(boolArrayKlassObj()); | |
182 f(byteArrayKlassObj()); | |
183 f(charArrayKlassObj()); | |
184 f(intArrayKlassObj()); | |
185 f(shortArrayKlassObj()); | |
186 f(longArrayKlassObj()); | |
187 f(singleArrayKlassObj()); | |
188 f(doubleArrayKlassObj()); | |
189 } | |
190 | |
191 | |
192 void Universe::system_classes_do(void f(klassOop)) { | |
193 f(symbolKlassObj()); | |
194 f(methodKlassObj()); | |
195 f(constMethodKlassObj()); | |
196 f(methodDataKlassObj()); | |
197 f(klassKlassObj()); | |
198 f(arrayKlassKlassObj()); | |
199 f(objArrayKlassKlassObj()); | |
200 f(typeArrayKlassKlassObj()); | |
201 f(instanceKlassKlassObj()); | |
202 f(constantPoolKlassObj()); | |
203 f(systemObjArrayKlassObj()); | |
204 } | |
205 | |
206 void Universe::oops_do(OopClosure* f, bool do_all) { | |
207 | |
208 f->do_oop((oop*) &_int_mirror); | |
209 f->do_oop((oop*) &_float_mirror); | |
210 f->do_oop((oop*) &_double_mirror); | |
211 f->do_oop((oop*) &_byte_mirror); | |
212 f->do_oop((oop*) &_bool_mirror); | |
213 f->do_oop((oop*) &_char_mirror); | |
214 f->do_oop((oop*) &_long_mirror); | |
215 f->do_oop((oop*) &_short_mirror); | |
216 f->do_oop((oop*) &_void_mirror); | |
217 | |
218 // It's important to iterate over these guys even if they are null, | |
219 // since that's how shared heaps are restored. | |
220 for (int i = T_BOOLEAN; i < T_VOID+1; i++) { | |
221 f->do_oop((oop*) &_mirrors[i]); | |
222 } | |
223 assert(_mirrors[0] == NULL && _mirrors[T_BOOLEAN - 1] == NULL, "checking"); | |
224 | |
225 // %%% Consider moving those "shared oops" over here with the others. | |
226 f->do_oop((oop*)&_boolArrayKlassObj); | |
227 f->do_oop((oop*)&_byteArrayKlassObj); | |
228 f->do_oop((oop*)&_charArrayKlassObj); | |
229 f->do_oop((oop*)&_intArrayKlassObj); | |
230 f->do_oop((oop*)&_shortArrayKlassObj); | |
231 f->do_oop((oop*)&_longArrayKlassObj); | |
232 f->do_oop((oop*)&_singleArrayKlassObj); | |
233 f->do_oop((oop*)&_doubleArrayKlassObj); | |
234 f->do_oop((oop*)&_objectArrayKlassObj); | |
235 { | |
236 for (int i = 0; i < T_VOID+1; i++) { | |
237 if (_typeArrayKlassObjs[i] != NULL) { | |
238 assert(i >= T_BOOLEAN, "checking"); | |
239 f->do_oop((oop*)&_typeArrayKlassObjs[i]); | |
240 } else if (do_all) { | |
241 f->do_oop((oop*)&_typeArrayKlassObjs[i]); | |
242 } | |
243 } | |
244 } | |
245 f->do_oop((oop*)&_symbolKlassObj); | |
246 f->do_oop((oop*)&_methodKlassObj); | |
247 f->do_oop((oop*)&_constMethodKlassObj); | |
248 f->do_oop((oop*)&_methodDataKlassObj); | |
249 f->do_oop((oop*)&_klassKlassObj); | |
250 f->do_oop((oop*)&_arrayKlassKlassObj); | |
251 f->do_oop((oop*)&_objArrayKlassKlassObj); | |
252 f->do_oop((oop*)&_typeArrayKlassKlassObj); | |
253 f->do_oop((oop*)&_instanceKlassKlassObj); | |
254 f->do_oop((oop*)&_constantPoolKlassObj); | |
255 f->do_oop((oop*)&_constantPoolCacheKlassObj); | |
256 f->do_oop((oop*)&_compiledICHolderKlassObj); | |
257 f->do_oop((oop*)&_systemObjArrayKlassObj); | |
258 f->do_oop((oop*)&_the_empty_byte_array); | |
259 f->do_oop((oop*)&_the_empty_short_array); | |
260 f->do_oop((oop*)&_the_empty_int_array); | |
261 f->do_oop((oop*)&_the_empty_system_obj_array); | |
262 f->do_oop((oop*)&_the_empty_class_klass_array); | |
263 f->do_oop((oop*)&_the_array_interfaces_array); | |
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
264 f->do_oop((oop*)&_the_null_string); |
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
265 f->do_oop((oop*)&_the_min_jint_string); |
0 | 266 _finalizer_register_cache->oops_do(f); |
267 _loader_addClass_cache->oops_do(f); | |
268 _reflect_invoke_cache->oops_do(f); | |
269 f->do_oop((oop*)&_out_of_memory_error_java_heap); | |
270 f->do_oop((oop*)&_out_of_memory_error_perm_gen); | |
271 f->do_oop((oop*)&_out_of_memory_error_array_size); | |
272 f->do_oop((oop*)&_out_of_memory_error_gc_overhead_limit); | |
273 if (_preallocated_out_of_memory_error_array != (oop)NULL) { // NULL when DumpSharedSpaces | |
274 f->do_oop((oop*)&_preallocated_out_of_memory_error_array); | |
275 } | |
276 f->do_oop((oop*)&_null_ptr_exception_instance); | |
277 f->do_oop((oop*)&_arithmetic_exception_instance); | |
278 f->do_oop((oop*)&_virtual_machine_error_instance); | |
279 f->do_oop((oop*)&_main_thread_group); | |
280 f->do_oop((oop*)&_system_thread_group); | |
281 f->do_oop((oop*)&_vm_exception); | |
282 f->do_oop((oop*)&_emptySymbol); | |
283 debug_only(f->do_oop((oop*)&_fullgc_alot_dummy_array);) | |
284 } | |
285 | |
286 | |
287 void Universe::check_alignment(uintx size, uintx alignment, const char* name) { | |
288 if (size < alignment || size % alignment != 0) { | |
289 ResourceMark rm; | |
290 stringStream st; | |
291 st.print("Size of %s (%ld bytes) must be aligned to %ld bytes", name, size, alignment); | |
292 char* error = st.as_string(); | |
293 vm_exit_during_initialization(error); | |
294 } | |
295 } | |
296 | |
297 | |
298 void Universe::genesis(TRAPS) { | |
299 ResourceMark rm; | |
300 { FlagSetting fs(_bootstrapping, true); | |
301 | |
302 { MutexLocker mc(Compile_lock); | |
303 | |
304 // determine base vtable size; without that we cannot create the array klasses | |
305 compute_base_vtable_size(); | |
306 | |
307 if (!UseSharedSpaces) { | |
308 _klassKlassObj = klassKlass::create_klass(CHECK); | |
309 _arrayKlassKlassObj = arrayKlassKlass::create_klass(CHECK); | |
310 | |
311 _objArrayKlassKlassObj = objArrayKlassKlass::create_klass(CHECK); | |
312 _instanceKlassKlassObj = instanceKlassKlass::create_klass(CHECK); | |
313 _typeArrayKlassKlassObj = typeArrayKlassKlass::create_klass(CHECK); | |
314 | |
315 _symbolKlassObj = symbolKlass::create_klass(CHECK); | |
316 | |
317 _emptySymbol = oopFactory::new_symbol("", CHECK); | |
318 | |
319 _boolArrayKlassObj = typeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK); | |
320 _charArrayKlassObj = typeArrayKlass::create_klass(T_CHAR, sizeof(jchar), CHECK); | |
321 _singleArrayKlassObj = typeArrayKlass::create_klass(T_FLOAT, sizeof(jfloat), CHECK); | |
322 _doubleArrayKlassObj = typeArrayKlass::create_klass(T_DOUBLE, sizeof(jdouble), CHECK); | |
323 _byteArrayKlassObj = typeArrayKlass::create_klass(T_BYTE, sizeof(jbyte), CHECK); | |
324 _shortArrayKlassObj = typeArrayKlass::create_klass(T_SHORT, sizeof(jshort), CHECK); | |
325 _intArrayKlassObj = typeArrayKlass::create_klass(T_INT, sizeof(jint), CHECK); | |
326 _longArrayKlassObj = typeArrayKlass::create_klass(T_LONG, sizeof(jlong), CHECK); | |
327 | |
328 _typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj; | |
329 _typeArrayKlassObjs[T_CHAR] = _charArrayKlassObj; | |
330 _typeArrayKlassObjs[T_FLOAT] = _singleArrayKlassObj; | |
331 _typeArrayKlassObjs[T_DOUBLE] = _doubleArrayKlassObj; | |
332 _typeArrayKlassObjs[T_BYTE] = _byteArrayKlassObj; | |
333 _typeArrayKlassObjs[T_SHORT] = _shortArrayKlassObj; | |
334 _typeArrayKlassObjs[T_INT] = _intArrayKlassObj; | |
335 _typeArrayKlassObjs[T_LONG] = _longArrayKlassObj; | |
336 | |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
337 _methodKlassObj = methodKlass::create_klass(CHECK); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
338 _constMethodKlassObj = constMethodKlass::create_klass(CHECK); |
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
339 _methodDataKlassObj = methodDataKlass::create_klass(CHECK); |
0 | 340 _constantPoolKlassObj = constantPoolKlass::create_klass(CHECK); |
341 _constantPoolCacheKlassObj = constantPoolCacheKlass::create_klass(CHECK); | |
342 | |
343 _compiledICHolderKlassObj = compiledICHolderKlass::create_klass(CHECK); | |
344 _systemObjArrayKlassObj = objArrayKlassKlass::cast(objArrayKlassKlassObj())->allocate_system_objArray_klass(CHECK); | |
345 | |
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
453
diff
changeset
|
346 _the_empty_byte_array = oopFactory::new_permanent_byteArray(0, CHECK); |
0 | 347 _the_empty_short_array = oopFactory::new_permanent_shortArray(0, CHECK); |
348 _the_empty_int_array = oopFactory::new_permanent_intArray(0, CHECK); | |
349 _the_empty_system_obj_array = oopFactory::new_system_objArray(0, CHECK); | |
350 | |
351 _the_array_interfaces_array = oopFactory::new_system_objArray(2, CHECK); | |
352 _vm_exception = oopFactory::new_symbol("vm exception holder", CHECK); | |
353 } else { | |
354 FileMapInfo *mapinfo = FileMapInfo::current_info(); | |
355 char* buffer = mapinfo->region_base(CompactingPermGenGen::md); | |
356 void** vtbl_list = (void**)buffer; | |
357 init_self_patching_vtbl_list(vtbl_list, | |
358 CompactingPermGenGen::vtbl_list_size); | |
359 } | |
360 } | |
361 | |
362 vmSymbols::initialize(CHECK); | |
363 | |
364 SystemDictionary::initialize(CHECK); | |
365 | |
1142 | 366 klassOop ok = SystemDictionary::Object_klass(); |
0 | 367 |
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
368 _the_null_string = StringTable::intern("null", CHECK); |
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
369 _the_min_jint_string = StringTable::intern("-2147483648", CHECK); |
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
1057
diff
changeset
|
370 |
0 | 371 if (UseSharedSpaces) { |
372 // Verify shared interfaces array. | |
373 assert(_the_array_interfaces_array->obj_at(0) == | |
1142 | 374 SystemDictionary::Cloneable_klass(), "u3"); |
0 | 375 assert(_the_array_interfaces_array->obj_at(1) == |
1142 | 376 SystemDictionary::Serializable_klass(), "u3"); |
0 | 377 |
378 // Verify element klass for system obj array klass | |
379 assert(objArrayKlass::cast(_systemObjArrayKlassObj)->element_klass() == ok, "u1"); | |
380 assert(objArrayKlass::cast(_systemObjArrayKlassObj)->bottom_klass() == ok, "u2"); | |
381 | |
382 // Verify super class for the classes created above | |
383 assert(Klass::cast(boolArrayKlassObj() )->super() == ok, "u3"); | |
384 assert(Klass::cast(charArrayKlassObj() )->super() == ok, "u3"); | |
385 assert(Klass::cast(singleArrayKlassObj() )->super() == ok, "u3"); | |
386 assert(Klass::cast(doubleArrayKlassObj() )->super() == ok, "u3"); | |
387 assert(Klass::cast(byteArrayKlassObj() )->super() == ok, "u3"); | |
388 assert(Klass::cast(shortArrayKlassObj() )->super() == ok, "u3"); | |
389 assert(Klass::cast(intArrayKlassObj() )->super() == ok, "u3"); | |
390 assert(Klass::cast(longArrayKlassObj() )->super() == ok, "u3"); | |
391 assert(Klass::cast(constantPoolKlassObj() )->super() == ok, "u3"); | |
392 assert(Klass::cast(systemObjArrayKlassObj())->super() == ok, "u3"); | |
393 } else { | |
394 // Set up shared interfaces array. (Do this before supers are set up.) | |
1142 | 395 _the_array_interfaces_array->obj_at_put(0, SystemDictionary::Cloneable_klass()); |
396 _the_array_interfaces_array->obj_at_put(1, SystemDictionary::Serializable_klass()); | |
0 | 397 |
398 // Set element klass for system obj array klass | |
399 objArrayKlass::cast(_systemObjArrayKlassObj)->set_element_klass(ok); | |
400 objArrayKlass::cast(_systemObjArrayKlassObj)->set_bottom_klass(ok); | |
401 | |
402 // Set super class for the classes created above | |
403 Klass::cast(boolArrayKlassObj() )->initialize_supers(ok, CHECK); | |
404 Klass::cast(charArrayKlassObj() )->initialize_supers(ok, CHECK); | |
405 Klass::cast(singleArrayKlassObj() )->initialize_supers(ok, CHECK); | |
406 Klass::cast(doubleArrayKlassObj() )->initialize_supers(ok, CHECK); | |
407 Klass::cast(byteArrayKlassObj() )->initialize_supers(ok, CHECK); | |
408 Klass::cast(shortArrayKlassObj() )->initialize_supers(ok, CHECK); | |
409 Klass::cast(intArrayKlassObj() )->initialize_supers(ok, CHECK); | |
410 Klass::cast(longArrayKlassObj() )->initialize_supers(ok, CHECK); | |
411 Klass::cast(constantPoolKlassObj() )->initialize_supers(ok, CHECK); | |
412 Klass::cast(systemObjArrayKlassObj())->initialize_supers(ok, CHECK); | |
413 Klass::cast(boolArrayKlassObj() )->set_super(ok); | |
414 Klass::cast(charArrayKlassObj() )->set_super(ok); | |
415 Klass::cast(singleArrayKlassObj() )->set_super(ok); | |
416 Klass::cast(doubleArrayKlassObj() )->set_super(ok); | |
417 Klass::cast(byteArrayKlassObj() )->set_super(ok); | |
418 Klass::cast(shortArrayKlassObj() )->set_super(ok); | |
419 Klass::cast(intArrayKlassObj() )->set_super(ok); | |
420 Klass::cast(longArrayKlassObj() )->set_super(ok); | |
421 Klass::cast(constantPoolKlassObj() )->set_super(ok); | |
422 Klass::cast(systemObjArrayKlassObj())->set_super(ok); | |
423 } | |
424 | |
425 Klass::cast(boolArrayKlassObj() )->append_to_sibling_list(); | |
426 Klass::cast(charArrayKlassObj() )->append_to_sibling_list(); | |
427 Klass::cast(singleArrayKlassObj() )->append_to_sibling_list(); | |
428 Klass::cast(doubleArrayKlassObj() )->append_to_sibling_list(); | |
429 Klass::cast(byteArrayKlassObj() )->append_to_sibling_list(); | |
430 Klass::cast(shortArrayKlassObj() )->append_to_sibling_list(); | |
431 Klass::cast(intArrayKlassObj() )->append_to_sibling_list(); | |
432 Klass::cast(longArrayKlassObj() )->append_to_sibling_list(); | |
433 Klass::cast(constantPoolKlassObj() )->append_to_sibling_list(); | |
434 Klass::cast(systemObjArrayKlassObj())->append_to_sibling_list(); | |
435 } // end of core bootstrapping | |
436 | |
437 // Initialize _objectArrayKlass after core bootstraping to make | |
438 // sure the super class is set up properly for _objectArrayKlass. | |
439 _objectArrayKlassObj = instanceKlass:: | |
1142 | 440 cast(SystemDictionary::Object_klass())->array_klass(1, CHECK); |
0 | 441 // Add the class to the class hierarchy manually to make sure that |
442 // its vtable is initialized after core bootstrapping is completed. | |
443 Klass::cast(_objectArrayKlassObj)->append_to_sibling_list(); | |
444 | |
445 // Compute is_jdk version flags. | |
446 // Only 1.3 or later has the java.lang.Shutdown class. | |
447 // Only 1.4 or later has the java.lang.CharSequence interface. | |
448 // Only 1.5 or later has the java.lang.management.MemoryUsage class. | |
242 | 449 if (JDK_Version::is_partially_initialized()) { |
450 uint8_t jdk_version; | |
451 klassOop k = SystemDictionary::resolve_or_null( | |
452 vmSymbolHandles::java_lang_management_MemoryUsage(), THREAD); | |
0 | 453 CLEAR_PENDING_EXCEPTION; // ignore exceptions |
454 if (k == NULL) { | |
242 | 455 k = SystemDictionary::resolve_or_null( |
456 vmSymbolHandles::java_lang_CharSequence(), THREAD); | |
0 | 457 CLEAR_PENDING_EXCEPTION; // ignore exceptions |
458 if (k == NULL) { | |
242 | 459 k = SystemDictionary::resolve_or_null( |
460 vmSymbolHandles::java_lang_Shutdown(), THREAD); | |
0 | 461 CLEAR_PENDING_EXCEPTION; // ignore exceptions |
462 if (k == NULL) { | |
242 | 463 jdk_version = 2; |
0 | 464 } else { |
242 | 465 jdk_version = 3; |
0 | 466 } |
467 } else { | |
242 | 468 jdk_version = 4; |
0 | 469 } |
470 } else { | |
242 | 471 jdk_version = 5; |
0 | 472 } |
242 | 473 JDK_Version::fully_initialize(jdk_version); |
0 | 474 } |
475 | |
476 #ifdef ASSERT | |
477 if (FullGCALot) { | |
478 // Allocate an array of dummy objects. | |
479 // We'd like these to be at the bottom of the old generation, | |
480 // so that when we free one and then collect, | |
481 // (almost) the whole heap moves | |
482 // and we find out if we actually update all the oops correctly. | |
483 // But we can't allocate directly in the old generation, | |
484 // so we allocate wherever, and hope that the first collection | |
485 // moves these objects to the bottom of the old generation. | |
486 // We can allocate directly in the permanent generation, so we do. | |
487 int size; | |
488 if (UseConcMarkSweepGC) { | |
489 warning("Using +FullGCALot with concurrent mark sweep gc " | |
490 "will not force all objects to relocate"); | |
491 size = FullGCALotDummies; | |
492 } else { | |
493 size = FullGCALotDummies * 2; | |
494 } | |
495 objArrayOop naked_array = oopFactory::new_system_objArray(size, CHECK); | |
496 objArrayHandle dummy_array(THREAD, naked_array); | |
497 int i = 0; | |
498 while (i < size) { | |
499 if (!UseConcMarkSweepGC) { | |
500 // Allocate dummy in old generation | |
1142 | 501 oop dummy = instanceKlass::cast(SystemDictionary::Object_klass())->allocate_instance(CHECK); |
0 | 502 dummy_array->obj_at_put(i++, dummy); |
503 } | |
504 // Allocate dummy in permanent generation | |
1142 | 505 oop dummy = instanceKlass::cast(SystemDictionary::Object_klass())->allocate_permanent_instance(CHECK); |
0 | 506 dummy_array->obj_at_put(i++, dummy); |
507 } | |
508 { | |
509 // Only modify the global variable inside the mutex. | |
510 // If we had a race to here, the other dummy_array instances | |
511 // and their elements just get dropped on the floor, which is fine. | |
512 MutexLocker ml(FullGCALot_lock); | |
513 if (_fullgc_alot_dummy_array == NULL) { | |
514 _fullgc_alot_dummy_array = dummy_array(); | |
515 } | |
516 } | |
517 assert(i == _fullgc_alot_dummy_array->length(), "just checking"); | |
518 } | |
519 #endif | |
520 } | |
521 | |
522 | |
523 static inline void add_vtable(void** list, int* n, Klass* o, int count) { | |
524 list[(*n)++] = *(void**)&o->vtbl_value(); | |
525 guarantee((*n) <= count, "vtable list too small."); | |
526 } | |
527 | |
528 | |
529 void Universe::init_self_patching_vtbl_list(void** list, int count) { | |
530 int n = 0; | |
531 { klassKlass o; add_vtable(list, &n, &o, count); } | |
532 { arrayKlassKlass o; add_vtable(list, &n, &o, count); } | |
533 { objArrayKlassKlass o; add_vtable(list, &n, &o, count); } | |
534 { instanceKlassKlass o; add_vtable(list, &n, &o, count); } | |
535 { instanceKlass o; add_vtable(list, &n, &o, count); } | |
536 { instanceRefKlass o; add_vtable(list, &n, &o, count); } | |
537 { typeArrayKlassKlass o; add_vtable(list, &n, &o, count); } | |
538 { symbolKlass o; add_vtable(list, &n, &o, count); } | |
539 { typeArrayKlass o; add_vtable(list, &n, &o, count); } | |
540 { methodKlass o; add_vtable(list, &n, &o, count); } | |
541 { constMethodKlass o; add_vtable(list, &n, &o, count); } | |
542 { constantPoolKlass o; add_vtable(list, &n, &o, count); } | |
543 { constantPoolCacheKlass o; add_vtable(list, &n, &o, count); } | |
544 { objArrayKlass o; add_vtable(list, &n, &o, count); } | |
545 { methodDataKlass o; add_vtable(list, &n, &o, count); } | |
546 { compiledICHolderKlass o; add_vtable(list, &n, &o, count); } | |
547 } | |
548 | |
549 | |
550 class FixupMirrorClosure: public ObjectClosure { | |
551 public: | |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
552 virtual void do_object(oop obj) { |
0 | 553 if (obj->is_klass()) { |
554 EXCEPTION_MARK; | |
555 KlassHandle k(THREAD, klassOop(obj)); | |
556 // We will never reach the CATCH below since Exceptions::_throw will cause | |
557 // the VM to exit if an exception is thrown during initialization | |
558 java_lang_Class::create_mirror(k, CATCH); | |
559 // This call unconditionally creates a new mirror for k, | |
560 // and links in k's component_mirror field if k is an array. | |
561 // If k is an objArray, k's element type must already have | |
562 // a mirror. In other words, this closure must process | |
563 // the component type of an objArray k before it processes k. | |
564 // This works because the permgen iterator presents arrays | |
565 // and their component types in order of creation. | |
566 } | |
567 } | |
568 }; | |
569 | |
570 void Universe::initialize_basic_type_mirrors(TRAPS) { | |
571 if (UseSharedSpaces) { | |
572 assert(_int_mirror != NULL, "already loaded"); | |
573 assert(_void_mirror == _mirrors[T_VOID], "consistently loaded"); | |
574 } else { | |
575 | |
576 assert(_int_mirror==NULL, "basic type mirrors already initialized"); | |
577 _int_mirror = | |
578 java_lang_Class::create_basic_type_mirror("int", T_INT, CHECK); | |
579 _float_mirror = | |
580 java_lang_Class::create_basic_type_mirror("float", T_FLOAT, CHECK); | |
581 _double_mirror = | |
582 java_lang_Class::create_basic_type_mirror("double", T_DOUBLE, CHECK); | |
583 _byte_mirror = | |
584 java_lang_Class::create_basic_type_mirror("byte", T_BYTE, CHECK); | |
585 _bool_mirror = | |
586 java_lang_Class::create_basic_type_mirror("boolean",T_BOOLEAN, CHECK); | |
587 _char_mirror = | |
588 java_lang_Class::create_basic_type_mirror("char", T_CHAR, CHECK); | |
589 _long_mirror = | |
590 java_lang_Class::create_basic_type_mirror("long", T_LONG, CHECK); | |
591 _short_mirror = | |
592 java_lang_Class::create_basic_type_mirror("short", T_SHORT, CHECK); | |
593 _void_mirror = | |
594 java_lang_Class::create_basic_type_mirror("void", T_VOID, CHECK); | |
595 | |
596 _mirrors[T_INT] = _int_mirror; | |
597 _mirrors[T_FLOAT] = _float_mirror; | |
598 _mirrors[T_DOUBLE] = _double_mirror; | |
599 _mirrors[T_BYTE] = _byte_mirror; | |
600 _mirrors[T_BOOLEAN] = _bool_mirror; | |
601 _mirrors[T_CHAR] = _char_mirror; | |
602 _mirrors[T_LONG] = _long_mirror; | |
603 _mirrors[T_SHORT] = _short_mirror; | |
604 _mirrors[T_VOID] = _void_mirror; | |
605 //_mirrors[T_OBJECT] = instanceKlass::cast(_object_klass)->java_mirror(); | |
606 //_mirrors[T_ARRAY] = instanceKlass::cast(_object_klass)->java_mirror(); | |
607 } | |
608 } | |
609 | |
610 void Universe::fixup_mirrors(TRAPS) { | |
611 // Bootstrap problem: all classes gets a mirror (java.lang.Class instance) assigned eagerly, | |
612 // but we cannot do that for classes created before java.lang.Class is loaded. Here we simply | |
613 // walk over permanent objects created so far (mostly classes) and fixup their mirrors. Note | |
614 // that the number of objects allocated at this point is very small. | |
1142 | 615 assert(SystemDictionary::Class_klass_loaded(), "java.lang.Class should be loaded"); |
0 | 616 FixupMirrorClosure blk; |
617 Universe::heap()->permanent_object_iterate(&blk); | |
618 } | |
619 | |
620 | |
621 static bool has_run_finalizers_on_exit = false; | |
622 | |
623 void Universe::run_finalizers_on_exit() { | |
624 if (has_run_finalizers_on_exit) return; | |
625 has_run_finalizers_on_exit = true; | |
626 | |
627 // Called on VM exit. This ought to be run in a separate thread. | |
628 if (TraceReferenceGC) tty->print_cr("Callback to run finalizers on exit"); | |
629 { | |
630 PRESERVE_EXCEPTION_MARK; | |
1142 | 631 KlassHandle finalizer_klass(THREAD, SystemDictionary::Finalizer_klass()); |
0 | 632 JavaValue result(T_VOID); |
633 JavaCalls::call_static( | |
634 &result, | |
635 finalizer_klass, | |
636 vmSymbolHandles::run_finalizers_on_exit_name(), | |
637 vmSymbolHandles::void_method_signature(), | |
638 THREAD | |
639 ); | |
640 // Ignore any pending exceptions | |
641 CLEAR_PENDING_EXCEPTION; | |
642 } | |
643 } | |
644 | |
645 | |
646 // initialize_vtable could cause gc if | |
647 // 1) we specified true to initialize_vtable and | |
648 // 2) this ran after gc was enabled | |
649 // In case those ever change we use handles for oops | |
650 void Universe::reinitialize_vtable_of(KlassHandle k_h, TRAPS) { | |
651 // init vtable of k and all subclasses | |
652 Klass* ko = k_h()->klass_part(); | |
653 klassVtable* vt = ko->vtable(); | |
654 if (vt) vt->initialize_vtable(false, CHECK); | |
655 if (ko->oop_is_instance()) { | |
656 instanceKlass* ik = (instanceKlass*)ko; | |
657 for (KlassHandle s_h(THREAD, ik->subklass()); s_h() != NULL; s_h = (THREAD, s_h()->klass_part()->next_sibling())) { | |
658 reinitialize_vtable_of(s_h, CHECK); | |
659 } | |
660 } | |
661 } | |
662 | |
663 | |
664 void initialize_itable_for_klass(klassOop k, TRAPS) { | |
665 instanceKlass::cast(k)->itable()->initialize_itable(false, CHECK); | |
666 } | |
667 | |
668 | |
669 void Universe::reinitialize_itables(TRAPS) { | |
670 SystemDictionary::classes_do(initialize_itable_for_klass, CHECK); | |
671 | |
672 } | |
673 | |
674 | |
675 bool Universe::on_page_boundary(void* addr) { | |
676 return ((uintptr_t) addr) % os::vm_page_size() == 0; | |
677 } | |
678 | |
679 | |
680 bool Universe::should_fill_in_stack_trace(Handle throwable) { | |
681 // never attempt to fill in the stack trace of preallocated errors that do not have | |
682 // backtrace. These errors are kept alive forever and may be "re-used" when all | |
683 // preallocated errors with backtrace have been consumed. Also need to avoid | |
684 // a potential loop which could happen if an out of memory occurs when attempting | |
685 // to allocate the backtrace. | |
686 return ((throwable() != Universe::_out_of_memory_error_java_heap) && | |
687 (throwable() != Universe::_out_of_memory_error_perm_gen) && | |
688 (throwable() != Universe::_out_of_memory_error_array_size) && | |
689 (throwable() != Universe::_out_of_memory_error_gc_overhead_limit)); | |
690 } | |
691 | |
692 | |
693 oop Universe::gen_out_of_memory_error(oop default_err) { | |
694 // generate an out of memory error: | |
695 // - if there is a preallocated error with backtrace available then return it wth | |
696 // a filled in stack trace. | |
697 // - if there are no preallocated errors with backtrace available then return | |
698 // an error without backtrace. | |
699 int next; | |
700 if (_preallocated_out_of_memory_error_avail_count > 0) { | |
701 next = (int)Atomic::add(-1, &_preallocated_out_of_memory_error_avail_count); | |
702 assert(next < (int)PreallocatedOutOfMemoryErrorCount, "avail count is corrupt"); | |
703 } else { | |
704 next = -1; | |
705 } | |
706 if (next < 0) { | |
707 // all preallocated errors have been used. | |
708 // return default | |
709 return default_err; | |
710 } else { | |
711 // get the error object at the slot and set set it to NULL so that the | |
712 // array isn't keeping it alive anymore. | |
713 oop exc = preallocated_out_of_memory_errors()->obj_at(next); | |
714 assert(exc != NULL, "slot has been used already"); | |
715 preallocated_out_of_memory_errors()->obj_at_put(next, NULL); | |
716 | |
717 // use the message from the default error | |
718 oop msg = java_lang_Throwable::message(default_err); | |
719 assert(msg != NULL, "no message"); | |
720 java_lang_Throwable::set_message(exc, msg); | |
721 | |
722 // populate the stack trace and return it. | |
723 java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(exc); | |
724 return exc; | |
725 } | |
726 } | |
727 | |
728 static intptr_t non_oop_bits = 0; | |
729 | |
730 void* Universe::non_oop_word() { | |
731 // Neither the high bits nor the low bits of this value is allowed | |
732 // to look like (respectively) the high or low bits of a real oop. | |
733 // | |
734 // High and low are CPU-specific notions, but low always includes | |
735 // the low-order bit. Since oops are always aligned at least mod 4, | |
736 // setting the low-order bit will ensure that the low half of the | |
737 // word will never look like that of a real oop. | |
738 // | |
739 // Using the OS-supplied non-memory-address word (usually 0 or -1) | |
740 // will take care of the high bits, however many there are. | |
741 | |
742 if (non_oop_bits == 0) { | |
743 non_oop_bits = (intptr_t)os::non_memory_address_word() | 1; | |
744 } | |
745 | |
746 return (void*)non_oop_bits; | |
747 } | |
748 | |
749 jint universe_init() { | |
750 assert(!Universe::_fully_initialized, "called after initialize_vtables"); | |
751 guarantee(1 << LogHeapWordSize == sizeof(HeapWord), | |
752 "LogHeapWordSize is incorrect."); | |
753 guarantee(sizeof(oop) >= sizeof(HeapWord), "HeapWord larger than oop?"); | |
754 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
|
755 "oop size is not not a multiple of HeapWord size"); |
0 | 756 TraceTime timer("Genesis", TraceStartupTime); |
757 GC_locker::lock(); // do not allow gc during bootstrapping | |
758 JavaClasses::compute_hard_coded_offsets(); | |
759 | |
760 // Get map info from shared archive file. | |
761 if (DumpSharedSpaces) | |
762 UseSharedSpaces = false; | |
763 | |
764 FileMapInfo* mapinfo = NULL; | |
765 if (UseSharedSpaces) { | |
766 mapinfo = NEW_C_HEAP_OBJ(FileMapInfo); | |
767 memset(mapinfo, 0, sizeof(FileMapInfo)); | |
768 | |
769 // Open the shared archive file, read and validate the header. If | |
770 // initialization files, shared spaces [UseSharedSpaces] are | |
771 // disabled and the file is closed. | |
772 | |
773 if (mapinfo->initialize()) { | |
774 FileMapInfo::set_current_info(mapinfo); | |
775 } else { | |
776 assert(!mapinfo->is_open() && !UseSharedSpaces, | |
777 "archive file not closed or shared spaces not disabled."); | |
778 } | |
779 } | |
780 | |
781 jint status = Universe::initialize_heap(); | |
782 if (status != JNI_OK) { | |
783 return status; | |
784 } | |
785 | |
786 // We have a heap so create the methodOop caches before | |
787 // CompactingPermGenGen::initialize_oops() tries to populate them. | |
788 Universe::_finalizer_register_cache = new LatestMethodOopCache(); | |
789 Universe::_loader_addClass_cache = new LatestMethodOopCache(); | |
790 Universe::_reflect_invoke_cache = new ActiveMethodOopsCache(); | |
791 | |
792 if (UseSharedSpaces) { | |
793 | |
794 // Read the data structures supporting the shared spaces (shared | |
795 // system dictionary, symbol table, etc.). After that, access to | |
796 // the file (other than the mapped regions) is no longer needed, and | |
797 // the file is closed. Closing the file does not affect the | |
798 // currently mapped regions. | |
799 | |
800 CompactingPermGenGen::initialize_oops(); | |
801 mapinfo->close(); | |
802 | |
803 } else { | |
804 SymbolTable::create_table(); | |
805 StringTable::create_table(); | |
806 ClassLoader::create_package_info_table(); | |
807 } | |
808 | |
809 return JNI_OK; | |
810 } | |
811 | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
812 // 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
|
813 // when compressed oops are used: |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
814 // 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
|
815 // NarrowOopHeapBaseMin + heap_size < 4Gb |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
816 // 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
|
817 // NarrowOopHeapBaseMin + heap_size < 32Gb |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
818 // 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
|
819 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
820 // 4Gb |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
821 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
|
822 // 32Gb |
1571
2d127394260e
6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb
kvn
parents:
1507
diff
changeset
|
823 // OopEncodingHeapMax == NarrowOopHeapMax << LogMinObjAlignmentInBytes; |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
824 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
825 char* Universe::preferred_heap_base(size_t heap_size, NARROW_OOP_MODE mode) { |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
826 size_t base = 0; |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
827 #ifdef _LP64 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
828 if (UseCompressedOops) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
829 assert(mode == UnscaledNarrowOop || |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
830 mode == ZeroBasedNarrowOop || |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
831 mode == HeapBasedNarrowOop, "mode is invalid"); |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
832 const size_t total_size = heap_size + HeapBaseMinAddress; |
922
1a81ea4b45d4
6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop")
kvn
parents:
845
diff
changeset
|
833 // Return specified base for the first request. |
1a81ea4b45d4
6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop")
kvn
parents:
845
diff
changeset
|
834 if (!FLAG_IS_DEFAULT(HeapBaseMinAddress) && (mode == UnscaledNarrowOop)) { |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
835 base = HeapBaseMinAddress; |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
836 } else if (total_size <= OopEncodingHeapMax && (mode != HeapBasedNarrowOop)) { |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
837 if (total_size <= NarrowOopHeapMax && (mode == UnscaledNarrowOop) && |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
838 (Universe::narrow_oop_shift() == 0)) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
839 // Use 32-bits oops without encoding and |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
840 // 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
|
841 base = (NarrowOopHeapMax - heap_size); |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
842 } else { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
843 // Can't reserve with NarrowOopShift == 0 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
844 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
845 if (mode == UnscaledNarrowOop || |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
846 mode == ZeroBasedNarrowOop && total_size <= NarrowOopHeapMax) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
847 // 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
|
848 // 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
|
849 // 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
|
850 base = (OopEncodingHeapMax - heap_size); |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
851 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
852 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
853 } else { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
854 // Can't reserve below 32Gb. |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
855 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
856 } |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
857 // 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
|
858 // 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
|
859 // The final values 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
|
860 if (base != 0 && (base + heap_size) <= OopEncodingHeapMax) { |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
861 // 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
|
862 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
|
863 // 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
|
864 // 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
|
865 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
|
866 } else { |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
867 // 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
|
868 // 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
|
869 // 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
|
870 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
|
871 #ifdef _WIN64 |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
872 if (UseLargePages) { |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
873 // 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
|
874 // 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
|
875 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
|
876 } |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
877 #endif // _WIN64 |
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
878 } |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
879 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
880 #endif |
1057
f334aec453a1
6896084: VM does not reserve protected page below heap for compressed oops implicit null checks
kvn
parents:
922
diff
changeset
|
881 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
|
882 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
883 |
0 | 884 jint Universe::initialize_heap() { |
885 | |
886 if (UseParallelGC) { | |
887 #ifndef SERIALGC | |
888 Universe::_collectedHeap = new ParallelScavengeHeap(); | |
889 #else // SERIALGC | |
890 fatal("UseParallelGC not supported in java kernel vm."); | |
891 #endif // SERIALGC | |
892 | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
893 } else if (UseG1GC) { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
894 #ifndef SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
895 G1CollectorPolicy* g1p = new G1CollectorPolicy_BestRegionsFirst(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
896 G1CollectedHeap* g1h = new G1CollectedHeap(g1p); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
897 Universe::_collectedHeap = g1h; |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
898 #else // SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
899 fatal("UseG1GC not supported in java kernel vm."); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
900 #endif // SERIALGC |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
901 |
0 | 902 } else { |
903 GenCollectorPolicy *gc_policy; | |
904 | |
905 if (UseSerialGC) { | |
906 gc_policy = new MarkSweepPolicy(); | |
907 } else if (UseConcMarkSweepGC) { | |
908 #ifndef SERIALGC | |
909 if (UseAdaptiveSizePolicy) { | |
910 gc_policy = new ASConcurrentMarkSweepPolicy(); | |
911 } else { | |
912 gc_policy = new ConcurrentMarkSweepPolicy(); | |
913 } | |
914 #else // SERIALGC | |
915 fatal("UseConcMarkSweepGC not supported in java kernel vm."); | |
916 #endif // SERIALGC | |
917 } else { // default old generation | |
918 gc_policy = new MarkSweepPolicy(); | |
919 } | |
920 | |
921 Universe::_collectedHeap = new GenCollectedHeap(gc_policy); | |
922 } | |
923 | |
924 jint status = Universe::heap()->initialize(); | |
925 if (status != JNI_OK) { | |
926 return status; | |
927 } | |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
928 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
929 #ifdef _LP64 |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
930 if (UseCompressedOops) { |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
931 // 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
|
932 // 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
|
933 // 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
|
934 // See needs_explicit_null_check. |
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
935 // 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
|
936 // compressed oops for pstack code. |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
937 if (PrintCompressedOopsMode) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
938 tty->cr(); |
1963 | 939 tty->print("heap address: " PTR_FORMAT ", size: " SIZE_FORMAT " MB", |
940 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
|
941 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
942 if ((uint64_t)Universe::heap()->reserved_region().end() > OopEncodingHeapMax) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
943 // Can't reserve heap below 32Gb. |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
944 Universe::set_narrow_oop_base(Universe::heap()->base() - os::vm_page_size()); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
945 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
946 if (PrintCompressedOopsMode) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
947 tty->print(", Compressed Oops with base: "PTR_FORMAT, Universe::narrow_oop_base()); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
948 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
949 } else { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
950 Universe::set_narrow_oop_base(0); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
951 if (PrintCompressedOopsMode) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
952 tty->print(", zero based Compressed Oops"); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
953 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
954 #ifdef _WIN64 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
955 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
|
956 // 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
|
957 // mode with zero based Compressed Oops. |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
958 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
|
959 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
960 #endif // _WIN64 |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
961 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
|
962 // Can't reserve heap below 4Gb. |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
963 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
964 } else { |
922
1a81ea4b45d4
6869822: assert(Universe::narrow_oop_shift() == 0,"use unscaled narrow oop")
kvn
parents:
845
diff
changeset
|
965 Universe::set_narrow_oop_shift(0); |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
966 if (PrintCompressedOopsMode) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
967 tty->print(", 32-bits Oops"); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
968 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
969 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
970 } |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
971 if (PrintCompressedOopsMode) { |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
972 tty->cr(); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
973 tty->cr(); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
974 } |
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
975 } |
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
976 assert(Universe::narrow_oop_base() == (Universe::heap()->base() - os::vm_page_size()) || |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
977 Universe::narrow_oop_base() == NULL, "invalid value"); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
978 assert(Universe::narrow_oop_shift() == LogMinObjAlignmentInBytes || |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
979 Universe::narrow_oop_shift() == 0, "invalid value"); |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
980 #endif |
0 | 981 |
982 // We will never reach the CATCH below since Exceptions::_throw will cause | |
983 // the VM to exit if an exception is thrown during initialization | |
984 | |
985 if (UseTLAB) { | |
986 assert(Universe::heap()->supports_tlab_allocation(), | |
987 "Should support thread-local allocation buffers"); | |
988 ThreadLocalAllocBuffer::startup_initialization(); | |
989 } | |
990 return JNI_OK; | |
991 } | |
992 | |
993 // It's the caller's repsonsibility to ensure glitch-freedom | |
994 // (if required). | |
995 void Universe::update_heap_info_at_gc() { | |
996 _heap_capacity_at_last_gc = heap()->capacity(); | |
997 _heap_used_at_last_gc = heap()->used(); | |
998 } | |
999 | |
1000 | |
1001 | |
1002 void universe2_init() { | |
1003 EXCEPTION_MARK; | |
1004 Universe::genesis(CATCH); | |
1005 // Although we'd like to verify here that the state of the heap | |
1006 // is good, we can't because the main thread has not yet added | |
1007 // itself to the threads list (so, using current interfaces | |
1008 // we can't "fill" its TLAB), unless TLABs are disabled. | |
1009 if (VerifyBeforeGC && !UseTLAB && | |
1010 Universe::heap()->total_collections() >= VerifyGCStartAt) { | |
1011 Universe::heap()->prepare_for_verify(); | |
1012 Universe::verify(); // make sure we're starting with a clean slate | |
1013 } | |
1014 } | |
1015 | |
1016 | |
1017 // This function is defined in JVM.cpp | |
1018 extern void initialize_converter_functions(); | |
1019 | |
1020 bool universe_post_init() { | |
1959
9eecf81a02fb
7000578: CMS: assert(SafepointSynchronize::is_at_safepoint()) failed: Else races are possible
ysr
parents:
1579
diff
changeset
|
1021 assert(!is_init_completed(), "Error: initialization not yet completed!"); |
0 | 1022 Universe::_fully_initialized = true; |
1023 EXCEPTION_MARK; | |
1024 { ResourceMark rm; | |
1025 Interpreter::initialize(); // needed for interpreter entry points | |
1026 if (!UseSharedSpaces) { | |
1142 | 1027 KlassHandle ok_h(THREAD, SystemDictionary::Object_klass()); |
0 | 1028 Universe::reinitialize_vtable_of(ok_h, CHECK_false); |
1029 Universe::reinitialize_itables(CHECK_false); | |
1030 } | |
1031 } | |
1032 | |
1033 klassOop k; | |
1034 instanceKlassHandle k_h; | |
1035 if (!UseSharedSpaces) { | |
1036 // Setup preallocated empty java.lang.Class array | |
1142 | 1037 Universe::_the_empty_class_klass_array = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_false); |
0 | 1038 // Setup preallocated OutOfMemoryError errors |
1039 k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_OutOfMemoryError(), true, CHECK_false); | |
1040 k_h = instanceKlassHandle(THREAD, k); | |
1041 Universe::_out_of_memory_error_java_heap = k_h->allocate_permanent_instance(CHECK_false); | |
1042 Universe::_out_of_memory_error_perm_gen = k_h->allocate_permanent_instance(CHECK_false); | |
1043 Universe::_out_of_memory_error_array_size = k_h->allocate_permanent_instance(CHECK_false); | |
1044 Universe::_out_of_memory_error_gc_overhead_limit = | |
1045 k_h->allocate_permanent_instance(CHECK_false); | |
1046 | |
1047 // Setup preallocated NullPointerException | |
1048 // (this is currently used for a cheap & dirty solution in compiler exception handling) | |
1049 k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_NullPointerException(), true, CHECK_false); | |
1050 Universe::_null_ptr_exception_instance = instanceKlass::cast(k)->allocate_permanent_instance(CHECK_false); | |
1051 // Setup preallocated ArithmeticException | |
1052 // (this is currently used for a cheap & dirty solution in compiler exception handling) | |
1053 k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_ArithmeticException(), true, CHECK_false); | |
1054 Universe::_arithmetic_exception_instance = instanceKlass::cast(k)->allocate_permanent_instance(CHECK_false); | |
1055 // Virtual Machine Error for when we get into a situation we can't resolve | |
1056 k = SystemDictionary::resolve_or_fail( | |
1057 vmSymbolHandles::java_lang_VirtualMachineError(), true, CHECK_false); | |
1058 bool linked = instanceKlass::cast(k)->link_class_or_fail(CHECK_false); | |
1059 if (!linked) { | |
1060 tty->print_cr("Unable to link/verify VirtualMachineError class"); | |
1061 return false; // initialization failed | |
1062 } | |
1063 Universe::_virtual_machine_error_instance = | |
1064 instanceKlass::cast(k)->allocate_permanent_instance(CHECK_false); | |
1065 } | |
1066 if (!DumpSharedSpaces) { | |
1067 // These are the only Java fields that are currently set during shared space dumping. | |
1068 // We prefer to not handle this generally, so we always reinitialize these detail messages. | |
1069 Handle msg = java_lang_String::create_from_str("Java heap space", CHECK_false); | |
1070 java_lang_Throwable::set_message(Universe::_out_of_memory_error_java_heap, msg()); | |
1071 | |
1072 msg = java_lang_String::create_from_str("PermGen space", CHECK_false); | |
1073 java_lang_Throwable::set_message(Universe::_out_of_memory_error_perm_gen, msg()); | |
1074 | |
1075 msg = java_lang_String::create_from_str("Requested array size exceeds VM limit", CHECK_false); | |
1076 java_lang_Throwable::set_message(Universe::_out_of_memory_error_array_size, msg()); | |
1077 | |
1078 msg = java_lang_String::create_from_str("GC overhead limit exceeded", CHECK_false); | |
1079 java_lang_Throwable::set_message(Universe::_out_of_memory_error_gc_overhead_limit, msg()); | |
1080 | |
1081 msg = java_lang_String::create_from_str("/ by zero", CHECK_false); | |
1082 java_lang_Throwable::set_message(Universe::_arithmetic_exception_instance, msg()); | |
1083 | |
1084 // Setup the array of errors that have preallocated backtrace | |
1085 k = Universe::_out_of_memory_error_java_heap->klass(); | |
1086 assert(k->klass_part()->name() == vmSymbols::java_lang_OutOfMemoryError(), "should be out of memory error"); | |
1087 k_h = instanceKlassHandle(THREAD, k); | |
1088 | |
1089 int len = (StackTraceInThrowable) ? (int)PreallocatedOutOfMemoryErrorCount : 0; | |
1090 Universe::_preallocated_out_of_memory_error_array = oopFactory::new_objArray(k_h(), len, CHECK_false); | |
1091 for (int i=0; i<len; i++) { | |
1092 oop err = k_h->allocate_permanent_instance(CHECK_false); | |
1093 Handle err_h = Handle(THREAD, err); | |
1094 java_lang_Throwable::allocate_backtrace(err_h, CHECK_false); | |
1095 Universe::preallocated_out_of_memory_errors()->obj_at_put(i, err_h()); | |
1096 } | |
1097 Universe::_preallocated_out_of_memory_error_avail_count = (jint)len; | |
1098 } | |
1099 | |
1100 | |
1101 // Setup static method for registering finalizers | |
1102 // The finalizer klass must be linked before looking up the method, in | |
1103 // case it needs to get rewritten. | |
1142 | 1104 instanceKlass::cast(SystemDictionary::Finalizer_klass())->link_class(CHECK_false); |
1105 methodOop m = instanceKlass::cast(SystemDictionary::Finalizer_klass())->find_method( | |
0 | 1106 vmSymbols::register_method_name(), |
1107 vmSymbols::register_method_signature()); | |
1108 if (m == NULL || !m->is_static()) { | |
1109 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodException(), | |
1110 "java.lang.ref.Finalizer.register", false); | |
1111 } | |
1112 Universe::_finalizer_register_cache->init( | |
1142 | 1113 SystemDictionary::Finalizer_klass(), m, CHECK_false); |
0 | 1114 |
1115 // Resolve on first use and initialize class. | |
1116 // Note: No race-condition here, since a resolve will always return the same result | |
1117 | |
1118 // Setup method for security checks | |
1119 k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_reflect_Method(), true, CHECK_false); | |
1120 k_h = instanceKlassHandle(THREAD, k); | |
1121 k_h->link_class(CHECK_false); | |
1507
cd5dbf694d45
6939134: JSR 292 adjustments to method handle invocation
jrose
parents:
1142
diff
changeset
|
1122 m = k_h->find_method(vmSymbols::invoke_name(), vmSymbols::object_object_array_object_signature()); |
0 | 1123 if (m == NULL || m->is_static()) { |
1124 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodException(), | |
1125 "java.lang.reflect.Method.invoke", false); | |
1126 } | |
1127 Universe::_reflect_invoke_cache->init(k_h(), m, CHECK_false); | |
1128 | |
1129 // Setup method for registering loaded classes in class loader vector | |
1142 | 1130 instanceKlass::cast(SystemDictionary::ClassLoader_klass())->link_class(CHECK_false); |
1131 m = instanceKlass::cast(SystemDictionary::ClassLoader_klass())->find_method(vmSymbols::addClass_name(), vmSymbols::class_void_signature()); | |
0 | 1132 if (m == NULL || m->is_static()) { |
1133 THROW_MSG_(vmSymbols::java_lang_NoSuchMethodException(), | |
1134 "java.lang.ClassLoader.addClass", false); | |
1135 } | |
1136 Universe::_loader_addClass_cache->init( | |
1142 | 1137 SystemDictionary::ClassLoader_klass(), m, CHECK_false); |
0 | 1138 |
1139 // The folowing is initializing converter functions for serialization in | |
1140 // JVM.cpp. If we clean up the StrictMath code above we may want to find | |
1141 // a better solution for this as well. | |
1142 initialize_converter_functions(); | |
1143 | |
1144 // This needs to be done before the first scavenge/gc, since | |
1145 // it's an input to soft ref clearing policy. | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1146 { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1147 MutexLocker x(Heap_lock); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1148 Universe::update_heap_info_at_gc(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1149 } |
0 | 1150 |
1151 // ("weak") refs processing infrastructure initialization | |
1152 Universe::heap()->post_initialize(); | |
1153 | |
1154 GC_locker::unlock(); // allow gc after bootstrapping | |
1155 | |
1156 MemoryService::set_universe_heap(Universe::_collectedHeap); | |
1157 return true; | |
1158 } | |
1159 | |
1160 | |
1161 void Universe::compute_base_vtable_size() { | |
1162 _base_vtable_size = ClassLoader::compute_Object_vtable(); | |
1163 } | |
1164 | |
1165 | |
1166 // %%% The Universe::flush_foo methods belong in CodeCache. | |
1167 | |
1168 // Flushes compiled methods dependent on dependee. | |
1169 void Universe::flush_dependents_on(instanceKlassHandle dependee) { | |
1170 assert_lock_strong(Compile_lock); | |
1171 | |
1172 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return; | |
1173 | |
1174 // CodeCache can only be updated by a thread_in_VM and they will all be | |
1175 // stopped dring the safepoint so CodeCache will be safe to update without | |
1176 // holding the CodeCache_lock. | |
1177 | |
1178 DepChange changes(dependee); | |
1179 | |
1180 // Compute the dependent nmethods | |
1181 if (CodeCache::mark_for_deoptimization(changes) > 0) { | |
1182 // At least one nmethod has been marked for deoptimization | |
1183 VM_Deoptimize op; | |
1184 VMThread::execute(&op); | |
1185 } | |
1186 } | |
1187 | |
1188 #ifdef HOTSWAP | |
1189 // Flushes compiled methods dependent on dependee in the evolutionary sense | |
1190 void Universe::flush_evol_dependents_on(instanceKlassHandle ev_k_h) { | |
1191 // --- Compile_lock is not held. However we are at a safepoint. | |
1192 assert_locked_or_safepoint(Compile_lock); | |
1193 if (CodeCache::number_of_nmethods_with_dependencies() == 0) return; | |
1194 | |
1195 // CodeCache can only be updated by a thread_in_VM and they will all be | |
1196 // stopped dring the safepoint so CodeCache will be safe to update without | |
1197 // holding the CodeCache_lock. | |
1198 | |
1199 // Compute the dependent nmethods | |
1200 if (CodeCache::mark_for_evol_deoptimization(ev_k_h) > 0) { | |
1201 // At least one nmethod has been marked for deoptimization | |
1202 | |
1203 // All this already happens inside a VM_Operation, so we'll do all the work here. | |
1204 // Stuff copied from VM_Deoptimize and modified slightly. | |
1205 | |
1206 // We do not want any GCs to happen while we are in the middle of this VM operation | |
1207 ResourceMark rm; | |
1208 DeoptimizationMarker dm; | |
1209 | |
1210 // Deoptimize all activations depending on marked nmethods | |
1211 Deoptimization::deoptimize_dependents(); | |
1212 | |
1213 // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies) | |
1214 CodeCache::make_marked_nmethods_not_entrant(); | |
1215 } | |
1216 } | |
1217 #endif // HOTSWAP | |
1218 | |
1219 | |
1220 // Flushes compiled methods dependent on dependee | |
1221 void Universe::flush_dependents_on_method(methodHandle m_h) { | |
1222 // --- Compile_lock is not held. However we are at a safepoint. | |
1223 assert_locked_or_safepoint(Compile_lock); | |
1224 | |
1225 // CodeCache can only be updated by a thread_in_VM and they will all be | |
1226 // stopped dring the safepoint so CodeCache will be safe to update without | |
1227 // holding the CodeCache_lock. | |
1228 | |
1229 // Compute the dependent nmethods | |
1230 if (CodeCache::mark_for_deoptimization(m_h()) > 0) { | |
1231 // At least one nmethod has been marked for deoptimization | |
1232 | |
1233 // All this already happens inside a VM_Operation, so we'll do all the work here. | |
1234 // Stuff copied from VM_Deoptimize and modified slightly. | |
1235 | |
1236 // We do not want any GCs to happen while we are in the middle of this VM operation | |
1237 ResourceMark rm; | |
1238 DeoptimizationMarker dm; | |
1239 | |
1240 // Deoptimize all activations depending on marked nmethods | |
1241 Deoptimization::deoptimize_dependents(); | |
1242 | |
1243 // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies) | |
1244 CodeCache::make_marked_nmethods_not_entrant(); | |
1245 } | |
1246 } | |
1247 | |
1248 void Universe::print() { print_on(gclog_or_tty); } | |
1249 | |
1250 void Universe::print_on(outputStream* st) { | |
1251 st->print_cr("Heap"); | |
1252 heap()->print_on(st); | |
1253 } | |
1254 | |
1255 void Universe::print_heap_at_SIGBREAK() { | |
1256 if (PrintHeapAtSIGBREAK) { | |
1257 MutexLocker hl(Heap_lock); | |
1258 print_on(tty); | |
1259 tty->cr(); | |
1260 tty->flush(); | |
1261 } | |
1262 } | |
1263 | |
1264 void Universe::print_heap_before_gc(outputStream* st) { | |
1265 st->print_cr("{Heap before GC invocations=%u (full %u):", | |
1266 heap()->total_collections(), | |
1267 heap()->total_full_collections()); | |
1268 heap()->print_on(st); | |
1269 } | |
1270 | |
1271 void Universe::print_heap_after_gc(outputStream* st) { | |
1272 st->print_cr("Heap after GC invocations=%u (full %u):", | |
1273 heap()->total_collections(), | |
1274 heap()->total_full_collections()); | |
1275 heap()->print_on(st); | |
1276 st->print_cr("}"); | |
1277 } | |
1278 | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
647
diff
changeset
|
1279 void Universe::verify(bool allow_dirty, bool silent, bool option) { |
0 | 1280 if (SharedSkipVerify) { |
1281 return; | |
1282 } | |
1283 | |
1284 // The use of _verify_in_progress is a temporary work around for | |
1285 // 6320749. Don't bother with a creating a class to set and clear | |
1286 // it since it is only used in this method and the control flow is | |
1287 // straight forward. | |
1288 _verify_in_progress = true; | |
1289 | |
1290 COMPILER2_PRESENT( | |
1291 assert(!DerivedPointerTable::is_active(), | |
1292 "DPT should not be active during verification " | |
1293 "(of thread stacks below)"); | |
1294 ) | |
1295 | |
1296 ResourceMark rm; | |
1297 HandleMark hm; // Handles created during verification can be zapped | |
1298 _verify_count++; | |
1299 | |
1300 if (!silent) gclog_or_tty->print("[Verifying "); | |
1301 if (!silent) gclog_or_tty->print("threads "); | |
1302 Threads::verify(); | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
647
diff
changeset
|
1303 heap()->verify(allow_dirty, silent, option); |
0 | 1304 |
1305 if (!silent) gclog_or_tty->print("syms "); | |
1306 SymbolTable::verify(); | |
1307 if (!silent) gclog_or_tty->print("strs "); | |
1308 StringTable::verify(); | |
1309 { | |
1310 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
1311 if (!silent) gclog_or_tty->print("zone "); | |
1312 CodeCache::verify(); | |
1313 } | |
1314 if (!silent) gclog_or_tty->print("dict "); | |
1315 SystemDictionary::verify(); | |
1316 if (!silent) gclog_or_tty->print("hand "); | |
1317 JNIHandles::verify(); | |
1318 if (!silent) gclog_or_tty->print("C-heap "); | |
1319 os::check_heap(); | |
1320 if (!silent) gclog_or_tty->print_cr("]"); | |
1321 | |
1322 _verify_in_progress = false; | |
1323 } | |
1324 | |
1325 // Oop verification (see MacroAssembler::verify_oop) | |
1326 | |
1327 static uintptr_t _verify_oop_data[2] = {0, (uintptr_t)-1}; | |
1328 static uintptr_t _verify_klass_data[2] = {0, (uintptr_t)-1}; | |
1329 | |
1330 | |
1331 static void calculate_verify_data(uintptr_t verify_data[2], | |
1332 HeapWord* low_boundary, | |
1333 HeapWord* high_boundary) { | |
1334 assert(low_boundary < high_boundary, "bad interval"); | |
1335 | |
1336 // decide which low-order bits we require to be clear: | |
1337 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
|
1338 size_t min_object_size = CollectedHeap::min_fill_size(); |
0 | 1339 |
1340 // make an inclusive limit: | |
1341 uintptr_t max = (uintptr_t)high_boundary - min_object_size*wordSize; | |
1342 uintptr_t min = (uintptr_t)low_boundary; | |
1343 assert(min < max, "bad interval"); | |
1344 uintptr_t diff = max ^ min; | |
1345 | |
1346 // throw away enough low-order bits to make the diff vanish | |
1347 uintptr_t mask = (uintptr_t)(-1); | |
1348 while ((mask & diff) != 0) | |
1349 mask <<= 1; | |
1350 uintptr_t bits = (min & mask); | |
1351 assert(bits == (max & mask), "correct mask"); | |
1352 // check an intermediate value between min and max, just to make sure: | |
1353 assert(bits == ((min + (max-min)/2) & mask), "correct mask"); | |
1354 | |
1355 // require address alignment, too: | |
1356 mask |= (alignSize - 1); | |
1357 | |
1358 if (!(verify_data[0] == 0 && verify_data[1] == (uintptr_t)-1)) { | |
1359 assert(verify_data[0] == mask && verify_data[1] == bits, "mask stability"); | |
1360 } | |
1361 verify_data[0] = mask; | |
1362 verify_data[1] = bits; | |
1363 } | |
1364 | |
1365 | |
1366 // Oop verification (see MacroAssembler::verify_oop) | |
1367 #ifndef PRODUCT | |
1368 | |
1369 uintptr_t Universe::verify_oop_mask() { | |
1370 MemRegion m = heap()->reserved_region(); | |
1371 calculate_verify_data(_verify_oop_data, | |
1372 m.start(), | |
1373 m.end()); | |
1374 return _verify_oop_data[0]; | |
1375 } | |
1376 | |
1377 | |
1378 | |
1379 uintptr_t Universe::verify_oop_bits() { | |
1380 verify_oop_mask(); | |
1381 return _verify_oop_data[1]; | |
1382 } | |
1383 | |
1384 | |
1385 uintptr_t Universe::verify_klass_mask() { | |
1386 /* $$$ | |
1387 // A klass can never live in the new space. Since the new and old | |
1388 // spaces can change size, we must settle for bounds-checking against | |
1389 // the bottom of the world, plus the smallest possible new and old | |
1390 // space sizes that may arise during execution. | |
1391 size_t min_new_size = Universe::new_size(); // in bytes | |
1392 size_t min_old_size = Universe::old_size(); // in bytes | |
1393 calculate_verify_data(_verify_klass_data, | |
1394 (HeapWord*)((uintptr_t)_new_gen->low_boundary + min_new_size + min_old_size), | |
1395 _perm_gen->high_boundary); | |
1396 */ | |
1397 // Why doesn't the above just say that klass's always live in the perm | |
1398 // gen? I'll see if that seems to work... | |
1399 MemRegion permanent_reserved; | |
1400 switch (Universe::heap()->kind()) { | |
1401 default: | |
1402 // ???: What if a CollectedHeap doesn't have a permanent generation? | |
1403 ShouldNotReachHere(); | |
1404 break; | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1405 case CollectedHeap::GenCollectedHeap: |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1406 case CollectedHeap::G1CollectedHeap: { |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1407 SharedHeap* sh = (SharedHeap*) Universe::heap(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1408 permanent_reserved = sh->perm_gen()->reserved(); |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
113
diff
changeset
|
1409 break; |
0 | 1410 } |
1411 #ifndef SERIALGC | |
1412 case CollectedHeap::ParallelScavengeHeap: { | |
1413 ParallelScavengeHeap* psh = (ParallelScavengeHeap*) Universe::heap(); | |
1414 permanent_reserved = psh->perm_gen()->reserved(); | |
1415 break; | |
1416 } | |
1417 #endif // SERIALGC | |
1418 } | |
1419 calculate_verify_data(_verify_klass_data, | |
1420 permanent_reserved.start(), | |
1421 permanent_reserved.end()); | |
1422 | |
1423 return _verify_klass_data[0]; | |
1424 } | |
1425 | |
1426 | |
1427 | |
1428 uintptr_t Universe::verify_klass_bits() { | |
1429 verify_klass_mask(); | |
1430 return _verify_klass_data[1]; | |
1431 } | |
1432 | |
1433 | |
1434 uintptr_t Universe::verify_mark_mask() { | |
1435 return markOopDesc::lock_mask_in_place; | |
1436 } | |
1437 | |
1438 | |
1439 | |
1440 uintptr_t Universe::verify_mark_bits() { | |
1441 intptr_t mask = verify_mark_mask(); | |
1442 intptr_t bits = (intptr_t)markOopDesc::prototype(); | |
1443 assert((bits & ~mask) == 0, "no stray header bits"); | |
1444 return bits; | |
1445 } | |
1446 #endif // PRODUCT | |
1447 | |
1448 | |
1449 void Universe::compute_verify_oop_data() { | |
1450 verify_oop_mask(); | |
1451 verify_oop_bits(); | |
1452 verify_mark_mask(); | |
1453 verify_mark_bits(); | |
1454 verify_klass_mask(); | |
1455 verify_klass_bits(); | |
1456 } | |
1457 | |
1458 | |
1459 void CommonMethodOopCache::init(klassOop k, methodOop m, TRAPS) { | |
1460 if (!UseSharedSpaces) { | |
1461 _klass = k; | |
1462 } | |
1463 #ifndef PRODUCT | |
1464 else { | |
1465 // sharing initilization should have already set up _klass | |
1466 assert(_klass != NULL, "just checking"); | |
1467 } | |
1468 #endif | |
1469 | |
1470 _method_idnum = m->method_idnum(); | |
1471 assert(_method_idnum >= 0, "sanity check"); | |
1472 } | |
1473 | |
1474 | |
1475 ActiveMethodOopsCache::~ActiveMethodOopsCache() { | |
1476 if (_prev_methods != NULL) { | |
1477 for (int i = _prev_methods->length() - 1; i >= 0; i--) { | |
1478 jweak method_ref = _prev_methods->at(i); | |
1479 if (method_ref != NULL) { | |
1480 JNIHandles::destroy_weak_global(method_ref); | |
1481 } | |
1482 } | |
1483 delete _prev_methods; | |
1484 _prev_methods = NULL; | |
1485 } | |
1486 } | |
1487 | |
1488 | |
1489 void ActiveMethodOopsCache::add_previous_version(const methodOop method) { | |
1490 assert(Thread::current()->is_VM_thread(), | |
1491 "only VMThread can add previous versions"); | |
1492 | |
1493 if (_prev_methods == NULL) { | |
1494 // This is the first previous version so make some space. | |
1495 // Start with 2 elements under the assumption that the class | |
1496 // won't be redefined much. | |
1497 _prev_methods = new (ResourceObj::C_HEAP) GrowableArray<jweak>(2, true); | |
1498 } | |
1499 | |
1500 // RC_TRACE macro has an embedded ResourceMark | |
1501 RC_TRACE(0x00000100, | |
1502 ("add: %s(%s): adding prev version ref for cached method @%d", | |
1503 method->name()->as_C_string(), method->signature()->as_C_string(), | |
1504 _prev_methods->length())); | |
1505 | |
1506 methodHandle method_h(method); | |
1507 jweak method_ref = JNIHandles::make_weak_global(method_h); | |
1508 _prev_methods->append(method_ref); | |
1509 | |
1510 // Using weak references allows previous versions of the cached | |
1511 // method to be GC'ed when they are no longer needed. Since the | |
1512 // caller is the VMThread and we are at a safepoint, this is a good | |
1513 // time to clear out unused weak references. | |
1514 | |
1515 for (int i = _prev_methods->length() - 1; i >= 0; i--) { | |
1516 jweak method_ref = _prev_methods->at(i); | |
1517 assert(method_ref != NULL, "weak method ref was unexpectedly cleared"); | |
1518 if (method_ref == NULL) { | |
1519 _prev_methods->remove_at(i); | |
1520 // Since we are traversing the array backwards, we don't have to | |
1521 // do anything special with the index. | |
1522 continue; // robustness | |
1523 } | |
1524 | |
1525 methodOop m = (methodOop)JNIHandles::resolve(method_ref); | |
1526 if (m == NULL) { | |
1527 // this method entry has been GC'ed so remove it | |
1528 JNIHandles::destroy_weak_global(method_ref); | |
1529 _prev_methods->remove_at(i); | |
1530 } else { | |
1531 // RC_TRACE macro has an embedded ResourceMark | |
1532 RC_TRACE(0x00000400, ("add: %s(%s): previous cached method @%d is alive", | |
1533 m->name()->as_C_string(), m->signature()->as_C_string(), i)); | |
1534 } | |
1535 } | |
1536 } // end add_previous_version() | |
1537 | |
1538 | |
1539 bool ActiveMethodOopsCache::is_same_method(const methodOop method) const { | |
1540 instanceKlass* ik = instanceKlass::cast(klass()); | |
1541 methodOop check_method = ik->method_with_idnum(method_idnum()); | |
1542 assert(check_method != NULL, "sanity check"); | |
1543 if (check_method == method) { | |
1544 // done with the easy case | |
1545 return true; | |
1546 } | |
1547 | |
1548 if (_prev_methods != NULL) { | |
1549 // The cached method has been redefined at least once so search | |
1550 // the previous versions for a match. | |
1551 for (int i = 0; i < _prev_methods->length(); i++) { | |
1552 jweak method_ref = _prev_methods->at(i); | |
1553 assert(method_ref != NULL, "weak method ref was unexpectedly cleared"); | |
1554 if (method_ref == NULL) { | |
1555 continue; // robustness | |
1556 } | |
1557 | |
1558 check_method = (methodOop)JNIHandles::resolve(method_ref); | |
1559 if (check_method == method) { | |
1560 // a previous version matches | |
1561 return true; | |
1562 } | |
1563 } | |
1564 } | |
1565 | |
1566 // either no previous versions or no previous version matched | |
1567 return false; | |
1568 } | |
1569 | |
1570 | |
1571 methodOop LatestMethodOopCache::get_methodOop() { | |
1572 instanceKlass* ik = instanceKlass::cast(klass()); | |
1573 methodOop m = ik->method_with_idnum(method_idnum()); | |
1574 assert(m != NULL, "sanity check"); | |
1575 return m; | |
1576 } | |
1577 | |
1578 | |
1579 #ifdef ASSERT | |
1580 // Release dummy object(s) at bottom of heap | |
1581 bool Universe::release_fullgc_alot_dummy() { | |
1582 MutexLocker ml(FullGCALot_lock); | |
1583 if (_fullgc_alot_dummy_array != NULL) { | |
1584 if (_fullgc_alot_dummy_next >= _fullgc_alot_dummy_array->length()) { | |
1585 // No more dummies to release, release entire array instead | |
1586 _fullgc_alot_dummy_array = NULL; | |
1587 return false; | |
1588 } | |
1589 if (!UseConcMarkSweepGC) { | |
1590 // Release dummy at bottom of old generation | |
1591 _fullgc_alot_dummy_array->obj_at_put(_fullgc_alot_dummy_next++, NULL); | |
1592 } | |
1593 // Release dummy at bottom of permanent generation | |
1594 _fullgc_alot_dummy_array->obj_at_put(_fullgc_alot_dummy_next++, NULL); | |
1595 } | |
1596 return true; | |
1597 } | |
1598 | |
1599 #endif // ASSERT |