Mercurial > hg > truffle
annotate src/share/vm/memory/universe.hpp @ 3772:6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
Summary: Perform a heap verification after the first phase of G1's full GC using objects' mark words to determine liveness. The third parameter of the heap verification routines, which was used in G1 to determine which marking bitmap to use in liveness calculations, has been changed from a boolean to an enum with values defined for using the mark word, and the 'prev' and 'next' bitmaps.
Reviewed-by: tonyp, ysr
| author | johnc |
|---|---|
| date | Tue, 14 Jun 2011 11:01:10 -0700 |
| parents | 1d1603768966 |
| children | fdb992d83a87 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2426
1d1603768966
7010070: Update all 2010 Oracle-changed OpenJDK files to have the proper copyright dates - second pass
trims
parents:
2177
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1080
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1080
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:
1080
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_MEMORY_UNIVERSE_HPP |
| 26 #define SHARE_VM_MEMORY_UNIVERSE_HPP | |
| 27 | |
| 28 #include "runtime/handles.hpp" | |
| 29 #include "utilities/growableArray.hpp" | |
| 30 | |
| 0 | 31 // Universe is a name space holding known system classes and objects in the VM. |
| 32 // | |
| 33 // Loaded classes are accessible through the SystemDictionary. | |
| 34 // | |
| 35 // The object heap is allocated and accessed through Universe, and various allocation | |
| 36 // support is provided. Allocation by the interpreter and compiled code is done inline | |
| 37 // and bails out to Scavenge::invoke_and_allocate. | |
| 38 | |
| 39 class CollectedHeap; | |
| 40 class DeferredObjAllocEvent; | |
| 41 | |
| 42 | |
| 43 // Common parts of a methodOop cache. This cache safely interacts with | |
| 44 // the RedefineClasses API. | |
| 45 // | |
| 46 class CommonMethodOopCache : public CHeapObj { | |
| 47 // We save the klassOop and the idnum of methodOop in order to get | |
| 48 // the current cached methodOop. | |
| 49 private: | |
| 50 klassOop _klass; | |
| 51 int _method_idnum; | |
| 52 | |
| 53 public: | |
| 54 CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; } | |
| 55 ~CommonMethodOopCache() { _klass = NULL; _method_idnum = -1; } | |
| 56 | |
| 57 void init(klassOop k, methodOop m, TRAPS); | |
| 58 klassOop klass() const { return _klass; } | |
| 59 int method_idnum() const { return _method_idnum; } | |
| 60 | |
| 61 // GC support | |
| 62 void oops_do(OopClosure* f) { f->do_oop((oop*)&_klass); } | |
| 63 }; | |
| 64 | |
| 65 | |
| 66 // A helper class for caching a methodOop when the user of the cache | |
| 67 // cares about all versions of the methodOop. | |
| 68 // | |
| 69 class ActiveMethodOopsCache : public CommonMethodOopCache { | |
| 70 // This subclass adds weak references to older versions of the | |
| 71 // methodOop and a query method for a methodOop. | |
| 72 | |
| 73 private: | |
| 74 // If the cached methodOop has not been redefined, then | |
| 75 // _prev_methods will be NULL. If all of the previous | |
| 76 // versions of the method have been collected, then | |
| 77 // _prev_methods can have a length of zero. | |
| 78 GrowableArray<jweak>* _prev_methods; | |
| 79 | |
| 80 public: | |
| 81 ActiveMethodOopsCache() { _prev_methods = NULL; } | |
| 82 ~ActiveMethodOopsCache(); | |
| 83 | |
| 84 void add_previous_version(const methodOop method); | |
| 85 bool is_same_method(const methodOop method) const; | |
| 86 }; | |
| 87 | |
| 88 | |
| 89 // A helper class for caching a methodOop when the user of the cache | |
| 90 // only cares about the latest version of the methodOop. | |
| 91 // | |
| 92 class LatestMethodOopCache : public CommonMethodOopCache { | |
| 93 // This subclass adds a getter method for the latest methodOop. | |
| 94 | |
| 95 public: | |
| 96 methodOop get_methodOop(); | |
| 97 }; | |
| 98 | |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
99 // For UseCompressedOops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
100 struct NarrowOopStruct { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
101 // Base address for oop-within-java-object materialization. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
102 // NULL if using wide oops or zero based narrow oops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
103 address _base; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
104 // Number of shift bits for encoding/decoding narrow oops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
105 // 0 if using wide oops or zero based unscaled narrow oops, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
106 // LogMinObjAlignmentInBytes otherwise. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
107 int _shift; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
108 // Generate code with implicit null checks for narrow oops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
109 bool _use_implicit_null_checks; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
110 }; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
111 |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
112 enum VerifyOption { |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
113 VerifyOption_Default = 0, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
114 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
115 // G1 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
116 VerifyOption_G1UsePrevMarking = VerifyOption_Default, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
117 VerifyOption_G1UseNextMarking = VerifyOption_G1UsePrevMarking + 1, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
118 VerifyOption_G1UseMarkWord = VerifyOption_G1UseNextMarking + 1 |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
119 }; |
| 0 | 120 |
| 121 class Universe: AllStatic { | |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
196
diff
changeset
|
122 // Ugh. Universe is much too friendly. |
| 0 | 123 friend class MarkSweep; |
| 124 friend class oopDesc; | |
| 125 friend class ClassLoader; | |
| 126 friend class Arguments; | |
| 127 friend class SystemDictionary; | |
| 128 friend class VMStructs; | |
| 129 friend class CompactingPermGenGen; | |
| 130 friend class VM_PopulateDumpSharedSpace; | |
| 131 | |
| 132 friend jint universe_init(); | |
| 133 friend void universe2_init(); | |
| 134 friend bool universe_post_init(); | |
| 135 | |
| 136 private: | |
| 137 // Known classes in the VM | |
| 138 static klassOop _boolArrayKlassObj; | |
| 139 static klassOop _byteArrayKlassObj; | |
| 140 static klassOop _charArrayKlassObj; | |
| 141 static klassOop _intArrayKlassObj; | |
| 142 static klassOop _shortArrayKlassObj; | |
| 143 static klassOop _longArrayKlassObj; | |
| 144 static klassOop _singleArrayKlassObj; | |
| 145 static klassOop _doubleArrayKlassObj; | |
| 146 static klassOop _typeArrayKlassObjs[T_VOID+1]; | |
| 147 | |
| 148 static klassOop _objectArrayKlassObj; | |
| 149 | |
| 150 static klassOop _methodKlassObj; | |
| 151 static klassOop _constMethodKlassObj; | |
| 152 static klassOop _methodDataKlassObj; | |
| 153 static klassOop _klassKlassObj; | |
| 154 static klassOop _arrayKlassKlassObj; | |
| 155 static klassOop _objArrayKlassKlassObj; | |
| 156 static klassOop _typeArrayKlassKlassObj; | |
| 157 static klassOop _instanceKlassKlassObj; | |
| 158 static klassOop _constantPoolKlassObj; | |
| 159 static klassOop _constantPoolCacheKlassObj; | |
| 160 static klassOop _compiledICHolderKlassObj; | |
| 161 static klassOop _systemObjArrayKlassObj; | |
| 162 | |
| 163 // Known objects in the VM | |
| 164 | |
| 165 // Primitive objects | |
| 166 static oop _int_mirror; | |
| 167 static oop _float_mirror; | |
| 168 static oop _double_mirror; | |
| 169 static oop _byte_mirror; | |
| 170 static oop _bool_mirror; | |
| 171 static oop _char_mirror; | |
| 172 static oop _long_mirror; | |
| 173 static oop _short_mirror; | |
| 174 static oop _void_mirror; | |
| 175 | |
| 176 static oop _main_thread_group; // Reference to the main thread group object | |
| 177 static oop _system_thread_group; // Reference to the system thread group object | |
| 178 | |
| 179 static typeArrayOop _the_empty_byte_array; // Canonicalized byte array | |
| 180 static typeArrayOop _the_empty_short_array; // Canonicalized short array | |
| 181 static typeArrayOop _the_empty_int_array; // Canonicalized int array | |
| 182 static objArrayOop _the_empty_system_obj_array; // Canonicalized system obj array | |
| 183 static objArrayOop _the_empty_class_klass_array; // Canonicalized obj array of type java.lang.Class | |
| 184 static objArrayOop _the_array_interfaces_array; // Canonicalized 2-array of cloneable & serializable klasses | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
860
diff
changeset
|
185 static oop _the_null_string; // A cache of "null" as a Java string |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
860
diff
changeset
|
186 static oop _the_min_jint_string; // A cache of "-2147483648" as a Java string |
| 0 | 187 static LatestMethodOopCache* _finalizer_register_cache; // static method for registering finalizable objects |
| 188 static LatestMethodOopCache* _loader_addClass_cache; // method for registering loaded classes in class loader vector | |
| 189 static ActiveMethodOopsCache* _reflect_invoke_cache; // method for security checks | |
| 190 static oop _out_of_memory_error_java_heap; // preallocated error object (no backtrace) | |
| 191 static oop _out_of_memory_error_perm_gen; // preallocated error object (no backtrace) | |
| 192 static oop _out_of_memory_error_array_size;// preallocated error object (no backtrace) | |
| 193 static oop _out_of_memory_error_gc_overhead_limit; // preallocated error object (no backtrace) | |
| 194 | |
| 195 // array of preallocated error objects with backtrace | |
| 196 static objArrayOop _preallocated_out_of_memory_error_array; | |
| 197 | |
| 198 // number of preallocated error objects available for use | |
| 199 static volatile jint _preallocated_out_of_memory_error_avail_count; | |
| 200 | |
| 201 static oop _null_ptr_exception_instance; // preallocated exception object | |
| 202 static oop _arithmetic_exception_instance; // preallocated exception object | |
| 203 static oop _virtual_machine_error_instance; // preallocated exception object | |
| 204 // The object used as an exception dummy when exceptions are thrown for | |
| 205 // the vm thread. | |
| 206 static oop _vm_exception; | |
| 207 | |
| 208 // The particular choice of collected heap. | |
| 209 static CollectedHeap* _collectedHeap; | |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
210 |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
211 // For UseCompressedOops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
212 static struct NarrowOopStruct _narrow_oop; |
| 0 | 213 |
| 214 // array of dummy objects used with +FullGCAlot | |
| 215 debug_only(static objArrayOop _fullgc_alot_dummy_array;) | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
216 // index of next entry to clear |
| 0 | 217 debug_only(static int _fullgc_alot_dummy_next;) |
| 218 | |
| 219 // Compiler/dispatch support | |
| 220 static int _base_vtable_size; // Java vtbl size of klass Object (in words) | |
| 221 | |
| 222 // Initialization | |
| 223 static bool _bootstrapping; // true during genesis | |
| 224 static bool _fully_initialized; // true after universe_init and initialize_vtables called | |
| 225 | |
| 226 // the array of preallocated errors with backtraces | |
| 227 static objArrayOop preallocated_out_of_memory_errors() { return _preallocated_out_of_memory_error_array; } | |
| 228 | |
| 229 // generate an out of memory error; if possible using an error with preallocated backtrace; | |
| 230 // otherwise return the given default error. | |
| 231 static oop gen_out_of_memory_error(oop default_err); | |
| 232 | |
| 233 // Historic gc information | |
| 234 static size_t _heap_capacity_at_last_gc; | |
| 235 static size_t _heap_used_at_last_gc; | |
| 236 | |
| 237 static jint initialize_heap(); | |
| 238 static void initialize_basic_type_mirrors(TRAPS); | |
| 239 static void fixup_mirrors(TRAPS); | |
| 240 | |
| 241 static void reinitialize_vtable_of(KlassHandle h_k, TRAPS); | |
| 242 static void reinitialize_itables(TRAPS); | |
| 243 static void compute_base_vtable_size(); // compute vtable size of class Object | |
| 244 | |
| 245 static void genesis(TRAPS); // Create the initial world | |
| 246 | |
| 247 // Mirrors for primitive classes (created eagerly) | |
| 248 static oop check_mirror(oop m) { | |
| 249 assert(m != NULL, "mirror not initialized"); | |
| 250 return m; | |
| 251 } | |
| 252 | |
| 253 // Debugging | |
| 254 static int _verify_count; // number of verifies done | |
| 255 // True during call to verify(). Should only be set/cleared in verify(). | |
| 256 static bool _verify_in_progress; | |
| 257 | |
| 258 static void compute_verify_oop_data(); | |
| 259 | |
| 260 public: | |
| 261 // Known classes in the VM | |
| 262 static klassOop boolArrayKlassObj() { return _boolArrayKlassObj; } | |
| 263 static klassOop byteArrayKlassObj() { return _byteArrayKlassObj; } | |
| 264 static klassOop charArrayKlassObj() { return _charArrayKlassObj; } | |
| 265 static klassOop intArrayKlassObj() { return _intArrayKlassObj; } | |
| 266 static klassOop shortArrayKlassObj() { return _shortArrayKlassObj; } | |
| 267 static klassOop longArrayKlassObj() { return _longArrayKlassObj; } | |
| 268 static klassOop singleArrayKlassObj() { return _singleArrayKlassObj; } | |
| 269 static klassOop doubleArrayKlassObj() { return _doubleArrayKlassObj; } | |
| 270 | |
| 271 static klassOop objectArrayKlassObj() { | |
| 272 return _objectArrayKlassObj; | |
| 273 } | |
| 274 | |
| 275 static klassOop typeArrayKlassObj(BasicType t) { | |
| 276 assert((uint)t < T_VOID+1, "range check"); | |
| 277 assert(_typeArrayKlassObjs[t] != NULL, "domain check"); | |
| 278 return _typeArrayKlassObjs[t]; | |
| 279 } | |
| 280 | |
| 281 static klassOop methodKlassObj() { return _methodKlassObj; } | |
| 282 static klassOop constMethodKlassObj() { return _constMethodKlassObj; } | |
| 283 static klassOop methodDataKlassObj() { return _methodDataKlassObj; } | |
| 284 static klassOop klassKlassObj() { return _klassKlassObj; } | |
| 285 static klassOop arrayKlassKlassObj() { return _arrayKlassKlassObj; } | |
| 286 static klassOop objArrayKlassKlassObj() { return _objArrayKlassKlassObj; } | |
| 287 static klassOop typeArrayKlassKlassObj() { return _typeArrayKlassKlassObj; } | |
| 288 static klassOop instanceKlassKlassObj() { return _instanceKlassKlassObj; } | |
| 289 static klassOop constantPoolKlassObj() { return _constantPoolKlassObj; } | |
| 290 static klassOop constantPoolCacheKlassObj() { return _constantPoolCacheKlassObj; } | |
| 291 static klassOop compiledICHolderKlassObj() { return _compiledICHolderKlassObj; } | |
| 292 static klassOop systemObjArrayKlassObj() { return _systemObjArrayKlassObj; } | |
| 293 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
294 // Known objects in the VM |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
295 static oop int_mirror() { return check_mirror(_int_mirror); } |
| 0 | 296 static oop float_mirror() { return check_mirror(_float_mirror); } |
| 297 static oop double_mirror() { return check_mirror(_double_mirror); } | |
| 298 static oop byte_mirror() { return check_mirror(_byte_mirror); } | |
| 299 static oop bool_mirror() { return check_mirror(_bool_mirror); } | |
| 300 static oop char_mirror() { return check_mirror(_char_mirror); } | |
| 301 static oop long_mirror() { return check_mirror(_long_mirror); } | |
| 302 static oop short_mirror() { return check_mirror(_short_mirror); } | |
| 303 static oop void_mirror() { return check_mirror(_void_mirror); } | |
| 304 | |
| 305 // table of same | |
| 306 static oop _mirrors[T_VOID+1]; | |
| 307 | |
| 308 static oop java_mirror(BasicType t) { | |
| 309 assert((uint)t < T_VOID+1, "range check"); | |
| 310 return check_mirror(_mirrors[t]); | |
| 311 } | |
| 312 static oop main_thread_group() { return _main_thread_group; } | |
| 313 static void set_main_thread_group(oop group) { _main_thread_group = group;} | |
| 314 | |
| 315 static oop system_thread_group() { return _system_thread_group; } | |
| 316 static void set_system_thread_group(oop group) { _system_thread_group = group;} | |
| 317 | |
| 318 static typeArrayOop the_empty_byte_array() { return _the_empty_byte_array; } | |
| 319 static typeArrayOop the_empty_short_array() { return _the_empty_short_array; } | |
| 320 static typeArrayOop the_empty_int_array() { return _the_empty_int_array; } | |
| 321 static objArrayOop the_empty_system_obj_array () { return _the_empty_system_obj_array; } | |
| 322 static objArrayOop the_empty_class_klass_array () { return _the_empty_class_klass_array; } | |
| 323 static objArrayOop the_array_interfaces_array() { return _the_array_interfaces_array; } | |
|
1080
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
860
diff
changeset
|
324 static oop the_null_string() { return _the_null_string; } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
860
diff
changeset
|
325 static oop the_min_jint_string() { return _the_min_jint_string; } |
| 0 | 326 static methodOop finalizer_register_method() { return _finalizer_register_cache->get_methodOop(); } |
| 327 static methodOop loader_addClass_method() { return _loader_addClass_cache->get_methodOop(); } | |
| 328 static ActiveMethodOopsCache* reflect_invoke_cache() { return _reflect_invoke_cache; } | |
| 329 static oop null_ptr_exception_instance() { return _null_ptr_exception_instance; } | |
| 330 static oop arithmetic_exception_instance() { return _arithmetic_exception_instance; } | |
| 331 static oop virtual_machine_error_instance() { return _virtual_machine_error_instance; } | |
| 332 static oop vm_exception() { return _vm_exception; } | |
| 333 | |
| 334 // OutOfMemoryError support. Returns an error with the required message. The returned error | |
| 335 // may or may not have a backtrace. If error has a backtrace then the stack trace is already | |
| 336 // filled in. | |
| 337 static oop out_of_memory_error_java_heap() { return gen_out_of_memory_error(_out_of_memory_error_java_heap); } | |
| 338 static oop out_of_memory_error_perm_gen() { return gen_out_of_memory_error(_out_of_memory_error_perm_gen); } | |
| 339 static oop out_of_memory_error_array_size() { return gen_out_of_memory_error(_out_of_memory_error_array_size); } | |
| 340 static oop out_of_memory_error_gc_overhead_limit() { return gen_out_of_memory_error(_out_of_memory_error_gc_overhead_limit); } | |
| 341 | |
| 342 // Accessors needed for fast allocation | |
| 343 static klassOop* boolArrayKlassObj_addr() { return &_boolArrayKlassObj; } | |
| 344 static klassOop* byteArrayKlassObj_addr() { return &_byteArrayKlassObj; } | |
| 345 static klassOop* charArrayKlassObj_addr() { return &_charArrayKlassObj; } | |
| 346 static klassOop* intArrayKlassObj_addr() { return &_intArrayKlassObj; } | |
| 347 static klassOop* shortArrayKlassObj_addr() { return &_shortArrayKlassObj; } | |
| 348 static klassOop* longArrayKlassObj_addr() { return &_longArrayKlassObj; } | |
| 349 static klassOop* singleArrayKlassObj_addr() { return &_singleArrayKlassObj; } | |
| 350 static klassOop* doubleArrayKlassObj_addr() { return &_doubleArrayKlassObj; } | |
|
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1552
diff
changeset
|
351 static klassOop* systemObjArrayKlassObj_addr() { return &_systemObjArrayKlassObj; } |
| 0 | 352 |
| 353 // The particular choice of collected heap. | |
| 354 static CollectedHeap* heap() { return _collectedHeap; } | |
| 355 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
356 // For UseCompressedOops |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
357 static address* narrow_oop_base_addr() { return &_narrow_oop._base; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
358 static address narrow_oop_base() { return _narrow_oop._base; } |
| 858 | 359 static bool is_narrow_oop_base(void* addr) { return (narrow_oop_base() == (address)addr); } |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
360 static int narrow_oop_shift() { return _narrow_oop._shift; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
361 static void set_narrow_oop_base(address base) { _narrow_oop._base = base; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
362 static void set_narrow_oop_shift(int shift) { _narrow_oop._shift = shift; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
363 static bool narrow_oop_use_implicit_null_checks() { return _narrow_oop._use_implicit_null_checks; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
364 static void set_narrow_oop_use_implicit_null_checks(bool use) { _narrow_oop._use_implicit_null_checks = use; } |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
365 // Narrow Oop encoding mode: |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
366 // 0 - Use 32-bits oops without encoding when |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
367 // NarrowOopHeapBaseMin + heap_size < 4Gb |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
368 // 1 - 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
|
369 // NarrowOopHeapBaseMin + heap_size < 32Gb |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
370 // 2 - Use compressed oops with heap base + encoding. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
371 enum NARROW_OOP_MODE { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
372 UnscaledNarrowOop = 0, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
373 ZeroBasedNarrowOop = 1, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
374 HeapBasedNarrowOop = 2 |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
375 }; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
376 static char* preferred_heap_base(size_t heap_size, NARROW_OOP_MODE mode); |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
377 |
| 0 | 378 // Historic gc information |
| 379 static size_t get_heap_capacity_at_last_gc() { return _heap_capacity_at_last_gc; } | |
| 380 static size_t get_heap_free_at_last_gc() { return _heap_capacity_at_last_gc - _heap_used_at_last_gc; } | |
| 381 static size_t get_heap_used_at_last_gc() { return _heap_used_at_last_gc; } | |
| 382 static void update_heap_info_at_gc(); | |
| 383 | |
| 384 // Testers | |
| 385 static bool is_bootstrapping() { return _bootstrapping; } | |
| 386 static bool is_fully_initialized() { return _fully_initialized; } | |
| 387 | |
| 388 static inline bool element_type_should_be_aligned(BasicType type); | |
| 389 static inline bool field_type_should_be_aligned(BasicType type); | |
| 390 static bool on_page_boundary(void* addr); | |
| 391 static bool should_fill_in_stack_trace(Handle throwable); | |
| 392 static void check_alignment(uintx size, uintx alignment, const char* name); | |
| 393 | |
| 394 // Finalizer support. | |
| 395 static void run_finalizers_on_exit(); | |
| 396 | |
| 397 // Iteration | |
| 398 | |
| 399 // Apply "f" to the addresses of all the direct heap pointers maintained | |
| 400 // as static fields of "Universe". | |
| 401 static void oops_do(OopClosure* f, bool do_all = false); | |
| 402 | |
| 403 // Apply "f" to all klasses for basic types (classes not present in | |
| 404 // SystemDictionary). | |
| 405 static void basic_type_classes_do(void f(klassOop)); | |
| 406 | |
| 407 // Apply "f" to all system klasses (classes not present in SystemDictionary). | |
| 408 static void system_classes_do(void f(klassOop)); | |
| 409 | |
| 410 // For sharing -- fill in a list of known vtable pointers. | |
| 411 static void init_self_patching_vtbl_list(void** list, int count); | |
| 412 | |
| 413 // Debugging | |
| 414 static bool verify_in_progress() { return _verify_in_progress; } | |
|
3772
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
415 static void verify(bool allow_dirty = true, bool silent = false, |
|
6747fd0512e0
7004681: G1: Extend marking verification to Full GCs
johnc
parents:
2426
diff
changeset
|
416 VerifyOption option = VerifyOption_Default ); |
| 0 | 417 static int verify_count() { return _verify_count; } |
| 418 static void print(); | |
| 419 static void print_on(outputStream* st); | |
| 420 static void print_heap_at_SIGBREAK(); | |
| 421 static void print_heap_before_gc() { print_heap_before_gc(gclog_or_tty); } | |
| 422 static void print_heap_after_gc() { print_heap_after_gc(gclog_or_tty); } | |
| 423 static void print_heap_before_gc(outputStream* st); | |
| 424 static void print_heap_after_gc(outputStream* st); | |
| 425 | |
| 426 // Change the number of dummy objects kept reachable by the full gc dummy | |
| 427 // array; this should trigger relocation in a sliding compaction collector. | |
| 428 debug_only(static bool release_fullgc_alot_dummy();) | |
| 429 // The non-oop pattern (see compiledIC.hpp, etc) | |
| 430 static void* non_oop_word(); | |
| 431 | |
| 432 // Oop verification (see MacroAssembler::verify_oop) | |
| 433 static uintptr_t verify_oop_mask() PRODUCT_RETURN0; | |
| 434 static uintptr_t verify_oop_bits() PRODUCT_RETURN0; | |
| 435 static uintptr_t verify_mark_bits() PRODUCT_RETURN0; | |
| 436 static uintptr_t verify_mark_mask() PRODUCT_RETURN0; | |
| 437 static uintptr_t verify_klass_mask() PRODUCT_RETURN0; | |
| 438 static uintptr_t verify_klass_bits() PRODUCT_RETURN0; | |
| 439 | |
| 440 // Flushing and deoptimization | |
| 441 static void flush_dependents_on(instanceKlassHandle dependee); | |
| 442 #ifdef HOTSWAP | |
| 443 // Flushing and deoptimization in case of evolution | |
| 444 static void flush_evol_dependents_on(instanceKlassHandle dependee); | |
| 445 #endif // HOTSWAP | |
| 446 // Support for fullspeed debugging | |
| 447 static void flush_dependents_on_method(methodHandle dependee); | |
| 448 | |
| 449 // Compiler support | |
| 450 static int base_vtable_size() { return _base_vtable_size; } | |
| 451 }; | |
| 452 | |
| 453 class DeferredObjAllocEvent : public CHeapObj { | |
| 454 private: | |
| 455 oop _oop; | |
| 456 size_t _bytesize; | |
| 457 jint _arena_id; | |
| 458 | |
| 459 public: | |
| 460 DeferredObjAllocEvent(const oop o, const size_t s, const jint id) { | |
| 461 _oop = o; | |
| 462 _bytesize = s; | |
| 463 _arena_id = id; | |
| 464 } | |
| 465 | |
| 466 ~DeferredObjAllocEvent() { | |
| 467 } | |
| 468 | |
| 469 jint arena_id() { return _arena_id; } | |
| 470 size_t bytesize() { return _bytesize; } | |
| 471 oop get_oop() { return _oop; } | |
| 472 }; | |
| 1972 | 473 |
| 474 #endif // SHARE_VM_MEMORY_UNIVERSE_HPP |