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