Mercurial > hg > truffle
annotate src/share/vm/memory/universe.hpp @ 2368:dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
6627787: CMS: JVM refuses to start up with -Xms16m -Xmx16m
7000125: CMS: Anti-monotone young gen sizing with respect to maximum whole heap size specification
7027529: CMS: retire CMSUseOldDefaults flag
Summary: Simplify CMS heap sizing code, relying on ergonomic initial sizing consistent with other collectors for the most part, controlling only young gen sizing to rein in pause times. Make CMS young gen sizing default statically cpu-dependant. Remove inconsistencies wrt generation sizing and policy code, allowing for the fixing for 6627787 and 7000125. For 7027529, retire the flag CMSUseOldDefaults which had been introduced as a bridge from JDK 5 to JDK 6 a number of years ago.
Reviewed-by: brutisso, poonam
| author | ysr |
|---|---|
| date | Wed, 16 Mar 2011 10:37:08 -0700 |
| parents | 3582bf76420e |
| children | 1d1603768966 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1552
diff
changeset
|
2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
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 |
| 0 | 112 |
| 113 class Universe: AllStatic { | |
|
481
7d7a7c599c17
6578152: fill_region_with_object has usability and safety issues
jcoomes
parents:
196
diff
changeset
|
114 // Ugh. Universe is much too friendly. |
| 0 | 115 friend class MarkSweep; |
| 116 friend class oopDesc; | |
| 117 friend class ClassLoader; | |
| 118 friend class Arguments; | |
| 119 friend class SystemDictionary; | |
| 120 friend class VMStructs; | |
| 121 friend class CompactingPermGenGen; | |
| 122 friend class VM_PopulateDumpSharedSpace; | |
| 123 | |
| 124 friend jint universe_init(); | |
| 125 friend void universe2_init(); | |
| 126 friend bool universe_post_init(); | |
| 127 | |
| 128 private: | |
| 129 // Known classes in the VM | |
| 130 static klassOop _boolArrayKlassObj; | |
| 131 static klassOop _byteArrayKlassObj; | |
| 132 static klassOop _charArrayKlassObj; | |
| 133 static klassOop _intArrayKlassObj; | |
| 134 static klassOop _shortArrayKlassObj; | |
| 135 static klassOop _longArrayKlassObj; | |
| 136 static klassOop _singleArrayKlassObj; | |
| 137 static klassOop _doubleArrayKlassObj; | |
| 138 static klassOop _typeArrayKlassObjs[T_VOID+1]; | |
| 139 | |
| 140 static klassOop _objectArrayKlassObj; | |
| 141 | |
| 142 static klassOop _methodKlassObj; | |
| 143 static klassOop _constMethodKlassObj; | |
| 144 static klassOop _methodDataKlassObj; | |
| 145 static klassOop _klassKlassObj; | |
| 146 static klassOop _arrayKlassKlassObj; | |
| 147 static klassOop _objArrayKlassKlassObj; | |
| 148 static klassOop _typeArrayKlassKlassObj; | |
| 149 static klassOop _instanceKlassKlassObj; | |
| 150 static klassOop _constantPoolKlassObj; | |
| 151 static klassOop _constantPoolCacheKlassObj; | |
| 152 static klassOop _compiledICHolderKlassObj; | |
| 153 static klassOop _systemObjArrayKlassObj; | |
| 154 | |
| 155 // Known objects in the VM | |
| 156 | |
| 157 // Primitive objects | |
| 158 static oop _int_mirror; | |
| 159 static oop _float_mirror; | |
| 160 static oop _double_mirror; | |
| 161 static oop _byte_mirror; | |
| 162 static oop _bool_mirror; | |
| 163 static oop _char_mirror; | |
| 164 static oop _long_mirror; | |
| 165 static oop _short_mirror; | |
| 166 static oop _void_mirror; | |
| 167 | |
| 168 static oop _main_thread_group; // Reference to the main thread group object | |
| 169 static oop _system_thread_group; // Reference to the system thread group object | |
| 170 | |
| 171 static typeArrayOop _the_empty_byte_array; // Canonicalized byte array | |
| 172 static typeArrayOop _the_empty_short_array; // Canonicalized short array | |
| 173 static typeArrayOop _the_empty_int_array; // Canonicalized int array | |
| 174 static objArrayOop _the_empty_system_obj_array; // Canonicalized system obj array | |
| 175 static objArrayOop _the_empty_class_klass_array; // Canonicalized obj array of type java.lang.Class | |
| 176 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
|
177 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
|
178 static oop _the_min_jint_string; // A cache of "-2147483648" as a Java string |
| 0 | 179 static LatestMethodOopCache* _finalizer_register_cache; // static method for registering finalizable objects |
| 180 static LatestMethodOopCache* _loader_addClass_cache; // method for registering loaded classes in class loader vector | |
| 181 static ActiveMethodOopsCache* _reflect_invoke_cache; // method for security checks | |
| 182 static oop _out_of_memory_error_java_heap; // preallocated error object (no backtrace) | |
| 183 static oop _out_of_memory_error_perm_gen; // preallocated error object (no backtrace) | |
| 184 static oop _out_of_memory_error_array_size;// preallocated error object (no backtrace) | |
| 185 static oop _out_of_memory_error_gc_overhead_limit; // preallocated error object (no backtrace) | |
| 186 | |
| 187 // array of preallocated error objects with backtrace | |
| 188 static objArrayOop _preallocated_out_of_memory_error_array; | |
| 189 | |
| 190 // number of preallocated error objects available for use | |
| 191 static volatile jint _preallocated_out_of_memory_error_avail_count; | |
| 192 | |
| 193 static oop _null_ptr_exception_instance; // preallocated exception object | |
| 194 static oop _arithmetic_exception_instance; // preallocated exception object | |
| 195 static oop _virtual_machine_error_instance; // preallocated exception object | |
| 196 // The object used as an exception dummy when exceptions are thrown for | |
| 197 // the vm thread. | |
| 198 static oop _vm_exception; | |
| 199 | |
| 200 // The particular choice of collected heap. | |
| 201 static CollectedHeap* _collectedHeap; | |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
202 |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
203 // For UseCompressedOops. |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
204 static struct NarrowOopStruct _narrow_oop; |
| 0 | 205 |
| 206 // array of dummy objects used with +FullGCAlot | |
| 207 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
|
208 // index of next entry to clear |
| 0 | 209 debug_only(static int _fullgc_alot_dummy_next;) |
| 210 | |
| 211 // Compiler/dispatch support | |
| 212 static int _base_vtable_size; // Java vtbl size of klass Object (in words) | |
| 213 | |
| 214 // Initialization | |
| 215 static bool _bootstrapping; // true during genesis | |
| 216 static bool _fully_initialized; // true after universe_init and initialize_vtables called | |
| 217 | |
| 218 // the array of preallocated errors with backtraces | |
| 219 static objArrayOop preallocated_out_of_memory_errors() { return _preallocated_out_of_memory_error_array; } | |
| 220 | |
| 221 // generate an out of memory error; if possible using an error with preallocated backtrace; | |
| 222 // otherwise return the given default error. | |
| 223 static oop gen_out_of_memory_error(oop default_err); | |
| 224 | |
| 225 // Historic gc information | |
| 226 static size_t _heap_capacity_at_last_gc; | |
| 227 static size_t _heap_used_at_last_gc; | |
| 228 | |
| 229 static jint initialize_heap(); | |
| 230 static void initialize_basic_type_mirrors(TRAPS); | |
| 231 static void fixup_mirrors(TRAPS); | |
| 232 | |
| 233 static void reinitialize_vtable_of(KlassHandle h_k, TRAPS); | |
| 234 static void reinitialize_itables(TRAPS); | |
| 235 static void compute_base_vtable_size(); // compute vtable size of class Object | |
| 236 | |
| 237 static void genesis(TRAPS); // Create the initial world | |
| 238 | |
| 239 // Mirrors for primitive classes (created eagerly) | |
| 240 static oop check_mirror(oop m) { | |
| 241 assert(m != NULL, "mirror not initialized"); | |
| 242 return m; | |
| 243 } | |
| 244 | |
| 245 // Debugging | |
| 246 static int _verify_count; // number of verifies done | |
| 247 // True during call to verify(). Should only be set/cleared in verify(). | |
| 248 static bool _verify_in_progress; | |
| 249 | |
| 250 static void compute_verify_oop_data(); | |
| 251 | |
| 252 public: | |
| 253 // Known classes in the VM | |
| 254 static klassOop boolArrayKlassObj() { return _boolArrayKlassObj; } | |
| 255 static klassOop byteArrayKlassObj() { return _byteArrayKlassObj; } | |
| 256 static klassOop charArrayKlassObj() { return _charArrayKlassObj; } | |
| 257 static klassOop intArrayKlassObj() { return _intArrayKlassObj; } | |
| 258 static klassOop shortArrayKlassObj() { return _shortArrayKlassObj; } | |
| 259 static klassOop longArrayKlassObj() { return _longArrayKlassObj; } | |
| 260 static klassOop singleArrayKlassObj() { return _singleArrayKlassObj; } | |
| 261 static klassOop doubleArrayKlassObj() { return _doubleArrayKlassObj; } | |
| 262 | |
| 263 static klassOop objectArrayKlassObj() { | |
| 264 return _objectArrayKlassObj; | |
| 265 } | |
| 266 | |
| 267 static klassOop typeArrayKlassObj(BasicType t) { | |
| 268 assert((uint)t < T_VOID+1, "range check"); | |
| 269 assert(_typeArrayKlassObjs[t] != NULL, "domain check"); | |
| 270 return _typeArrayKlassObjs[t]; | |
| 271 } | |
| 272 | |
| 273 static klassOop methodKlassObj() { return _methodKlassObj; } | |
| 274 static klassOop constMethodKlassObj() { return _constMethodKlassObj; } | |
| 275 static klassOop methodDataKlassObj() { return _methodDataKlassObj; } | |
| 276 static klassOop klassKlassObj() { return _klassKlassObj; } | |
| 277 static klassOop arrayKlassKlassObj() { return _arrayKlassKlassObj; } | |
| 278 static klassOop objArrayKlassKlassObj() { return _objArrayKlassKlassObj; } | |
| 279 static klassOop typeArrayKlassKlassObj() { return _typeArrayKlassKlassObj; } | |
| 280 static klassOop instanceKlassKlassObj() { return _instanceKlassKlassObj; } | |
| 281 static klassOop constantPoolKlassObj() { return _constantPoolKlassObj; } | |
| 282 static klassOop constantPoolCacheKlassObj() { return _constantPoolCacheKlassObj; } | |
| 283 static klassOop compiledICHolderKlassObj() { return _compiledICHolderKlassObj; } | |
| 284 static klassOop systemObjArrayKlassObj() { return _systemObjArrayKlassObj; } | |
| 285 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
286 // Known objects in the VM |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
287 static oop int_mirror() { return check_mirror(_int_mirror); } |
| 0 | 288 static oop float_mirror() { return check_mirror(_float_mirror); } |
| 289 static oop double_mirror() { return check_mirror(_double_mirror); } | |
| 290 static oop byte_mirror() { return check_mirror(_byte_mirror); } | |
| 291 static oop bool_mirror() { return check_mirror(_bool_mirror); } | |
| 292 static oop char_mirror() { return check_mirror(_char_mirror); } | |
| 293 static oop long_mirror() { return check_mirror(_long_mirror); } | |
| 294 static oop short_mirror() { return check_mirror(_short_mirror); } | |
| 295 static oop void_mirror() { return check_mirror(_void_mirror); } | |
| 296 | |
| 297 // table of same | |
| 298 static oop _mirrors[T_VOID+1]; | |
| 299 | |
| 300 static oop java_mirror(BasicType t) { | |
| 301 assert((uint)t < T_VOID+1, "range check"); | |
| 302 return check_mirror(_mirrors[t]); | |
| 303 } | |
| 304 static oop main_thread_group() { return _main_thread_group; } | |
| 305 static void set_main_thread_group(oop group) { _main_thread_group = group;} | |
| 306 | |
| 307 static oop system_thread_group() { return _system_thread_group; } | |
| 308 static void set_system_thread_group(oop group) { _system_thread_group = group;} | |
| 309 | |
| 310 static typeArrayOop the_empty_byte_array() { return _the_empty_byte_array; } | |
| 311 static typeArrayOop the_empty_short_array() { return _the_empty_short_array; } | |
| 312 static typeArrayOop the_empty_int_array() { return _the_empty_int_array; } | |
| 313 static objArrayOop the_empty_system_obj_array () { return _the_empty_system_obj_array; } | |
| 314 static objArrayOop the_empty_class_klass_array () { return _the_empty_class_klass_array; } | |
| 315 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
|
316 static oop the_null_string() { return _the_null_string; } |
|
7c57aead6d3e
6892658: C2 should optimize some stringbuilder patterns
never
parents:
860
diff
changeset
|
317 static oop the_min_jint_string() { return _the_min_jint_string; } |
| 0 | 318 static methodOop finalizer_register_method() { return _finalizer_register_cache->get_methodOop(); } |
| 319 static methodOop loader_addClass_method() { return _loader_addClass_cache->get_methodOop(); } | |
| 320 static ActiveMethodOopsCache* reflect_invoke_cache() { return _reflect_invoke_cache; } | |
| 321 static oop null_ptr_exception_instance() { return _null_ptr_exception_instance; } | |
| 322 static oop arithmetic_exception_instance() { return _arithmetic_exception_instance; } | |
| 323 static oop virtual_machine_error_instance() { return _virtual_machine_error_instance; } | |
| 324 static oop vm_exception() { return _vm_exception; } | |
| 325 | |
| 326 // OutOfMemoryError support. Returns an error with the required message. The returned error | |
| 327 // may or may not have a backtrace. If error has a backtrace then the stack trace is already | |
| 328 // filled in. | |
| 329 static oop out_of_memory_error_java_heap() { return gen_out_of_memory_error(_out_of_memory_error_java_heap); } | |
| 330 static oop out_of_memory_error_perm_gen() { return gen_out_of_memory_error(_out_of_memory_error_perm_gen); } | |
| 331 static oop out_of_memory_error_array_size() { return gen_out_of_memory_error(_out_of_memory_error_array_size); } | |
| 332 static oop out_of_memory_error_gc_overhead_limit() { return gen_out_of_memory_error(_out_of_memory_error_gc_overhead_limit); } | |
| 333 | |
| 334 // Accessors needed for fast allocation | |
| 335 static klassOop* boolArrayKlassObj_addr() { return &_boolArrayKlassObj; } | |
| 336 static klassOop* byteArrayKlassObj_addr() { return &_byteArrayKlassObj; } | |
| 337 static klassOop* charArrayKlassObj_addr() { return &_charArrayKlassObj; } | |
| 338 static klassOop* intArrayKlassObj_addr() { return &_intArrayKlassObj; } | |
| 339 static klassOop* shortArrayKlassObj_addr() { return &_shortArrayKlassObj; } | |
| 340 static klassOop* longArrayKlassObj_addr() { return &_longArrayKlassObj; } | |
| 341 static klassOop* singleArrayKlassObj_addr() { return &_singleArrayKlassObj; } | |
| 342 static klassOop* doubleArrayKlassObj_addr() { return &_doubleArrayKlassObj; } | |
|
1913
3b2dea75431e
6984311: JSR 292 needs optional bootstrap method parameters
jrose
parents:
1552
diff
changeset
|
343 static klassOop* systemObjArrayKlassObj_addr() { return &_systemObjArrayKlassObj; } |
| 0 | 344 |
| 345 // The particular choice of collected heap. | |
| 346 static CollectedHeap* heap() { return _collectedHeap; } | |
| 347 | |
|
113
ba764ed4b6f2
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
0
diff
changeset
|
348 // For UseCompressedOops |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
349 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
|
350 static address narrow_oop_base() { return _narrow_oop._base; } |
| 858 | 351 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
|
352 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
|
353 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
|
354 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
|
355 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
|
356 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
|
357 // Narrow Oop encoding mode: |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
358 // 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
|
359 // NarrowOopHeapBaseMin + heap_size < 4Gb |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
360 // 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
|
361 // NarrowOopHeapBaseMin + heap_size < 32Gb |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
362 // 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
|
363 enum NARROW_OOP_MODE { |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
364 UnscaledNarrowOop = 0, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
365 ZeroBasedNarrowOop = 1, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
366 HeapBasedNarrowOop = 2 |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
367 }; |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
494
diff
changeset
|
368 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
|
369 |
| 0 | 370 // Historic gc information |
| 371 static size_t get_heap_capacity_at_last_gc() { return _heap_capacity_at_last_gc; } | |
| 372 static size_t get_heap_free_at_last_gc() { return _heap_capacity_at_last_gc - _heap_used_at_last_gc; } | |
| 373 static size_t get_heap_used_at_last_gc() { return _heap_used_at_last_gc; } | |
| 374 static void update_heap_info_at_gc(); | |
| 375 | |
| 376 // Testers | |
| 377 static bool is_bootstrapping() { return _bootstrapping; } | |
| 378 static bool is_fully_initialized() { return _fully_initialized; } | |
| 379 | |
| 380 static inline bool element_type_should_be_aligned(BasicType type); | |
| 381 static inline bool field_type_should_be_aligned(BasicType type); | |
| 382 static bool on_page_boundary(void* addr); | |
| 383 static bool should_fill_in_stack_trace(Handle throwable); | |
| 384 static void check_alignment(uintx size, uintx alignment, const char* name); | |
| 385 | |
| 386 // Finalizer support. | |
| 387 static void run_finalizers_on_exit(); | |
| 388 | |
| 389 // Iteration | |
| 390 | |
| 391 // Apply "f" to the addresses of all the direct heap pointers maintained | |
| 392 // as static fields of "Universe". | |
| 393 static void oops_do(OopClosure* f, bool do_all = false); | |
| 394 | |
| 395 // Apply "f" to all klasses for basic types (classes not present in | |
| 396 // SystemDictionary). | |
| 397 static void basic_type_classes_do(void f(klassOop)); | |
| 398 | |
| 399 // Apply "f" to all system klasses (classes not present in SystemDictionary). | |
| 400 static void system_classes_do(void f(klassOop)); | |
| 401 | |
| 402 // For sharing -- fill in a list of known vtable pointers. | |
| 403 static void init_self_patching_vtbl_list(void** list, int count); | |
| 404 | |
| 405 // Debugging | |
| 406 static bool verify_in_progress() { return _verify_in_progress; } | |
|
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
647
diff
changeset
|
407 static void verify(bool allow_dirty = true, bool silent = false, bool option = true); |
| 0 | 408 static int verify_count() { return _verify_count; } |
| 409 static void print(); | |
| 410 static void print_on(outputStream* st); | |
| 411 static void print_heap_at_SIGBREAK(); | |
| 412 static void print_heap_before_gc() { print_heap_before_gc(gclog_or_tty); } | |
| 413 static void print_heap_after_gc() { print_heap_after_gc(gclog_or_tty); } | |
| 414 static void print_heap_before_gc(outputStream* st); | |
| 415 static void print_heap_after_gc(outputStream* st); | |
| 416 | |
| 417 // Change the number of dummy objects kept reachable by the full gc dummy | |
| 418 // array; this should trigger relocation in a sliding compaction collector. | |
| 419 debug_only(static bool release_fullgc_alot_dummy();) | |
| 420 // The non-oop pattern (see compiledIC.hpp, etc) | |
| 421 static void* non_oop_word(); | |
| 422 | |
| 423 // Oop verification (see MacroAssembler::verify_oop) | |
| 424 static uintptr_t verify_oop_mask() PRODUCT_RETURN0; | |
| 425 static uintptr_t verify_oop_bits() PRODUCT_RETURN0; | |
| 426 static uintptr_t verify_mark_bits() PRODUCT_RETURN0; | |
| 427 static uintptr_t verify_mark_mask() PRODUCT_RETURN0; | |
| 428 static uintptr_t verify_klass_mask() PRODUCT_RETURN0; | |
| 429 static uintptr_t verify_klass_bits() PRODUCT_RETURN0; | |
| 430 | |
| 431 // Flushing and deoptimization | |
| 432 static void flush_dependents_on(instanceKlassHandle dependee); | |
| 433 #ifdef HOTSWAP | |
| 434 // Flushing and deoptimization in case of evolution | |
| 435 static void flush_evol_dependents_on(instanceKlassHandle dependee); | |
| 436 #endif // HOTSWAP | |
| 437 // Support for fullspeed debugging | |
| 438 static void flush_dependents_on_method(methodHandle dependee); | |
| 439 | |
| 440 // Compiler support | |
| 441 static int base_vtable_size() { return _base_vtable_size; } | |
| 442 }; | |
| 443 | |
| 444 class DeferredObjAllocEvent : public CHeapObj { | |
| 445 private: | |
| 446 oop _oop; | |
| 447 size_t _bytesize; | |
| 448 jint _arena_id; | |
| 449 | |
| 450 public: | |
| 451 DeferredObjAllocEvent(const oop o, const size_t s, const jint id) { | |
| 452 _oop = o; | |
| 453 _bytesize = s; | |
| 454 _arena_id = id; | |
| 455 } | |
| 456 | |
| 457 ~DeferredObjAllocEvent() { | |
| 458 } | |
| 459 | |
| 460 jint arena_id() { return _arena_id; } | |
| 461 size_t bytesize() { return _bytesize; } | |
| 462 oop get_oop() { return _oop; } | |
| 463 }; | |
| 1972 | 464 |
| 465 #endif // SHARE_VM_MEMORY_UNIVERSE_HPP |