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