graal-jvmci-8: src/share/vm/memory/universe.hpp annotate

annotate src/share/vm/memory/universe.hpp @ 12233:40136aa2cdb1

8010722: assert: failed: heap size is too big for compressed oops Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation. Reviewed-by: stefank, dholmes

author	tschatzl
date	Wed, 11 Sep 2013 16:25:02 +0200
parents	7944aba7ba41
children	da051ce490eb

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	25 #ifndef SHARE_VM_MEMORY_UNIVERSE_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	26 #define SHARE_VM_MEMORY_UNIVERSE_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	28 #include "runtime/handles.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	29 #include "utilities/array.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	30 #include "utilities/growableArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	31
0 a61af66fc99e Initial load duke parents: diff changeset	32 // Universe is a name space holding known system classes and objects in the VM.
a61af66fc99e Initial load duke parents: diff changeset	33 //
a61af66fc99e Initial load duke parents: diff changeset	34 // Loaded classes are accessible through the SystemDictionary.
a61af66fc99e Initial load duke parents: diff changeset	35 //
a61af66fc99e Initial load duke parents: diff changeset	36 // The object heap is allocated and accessed through Universe, and various allocation
a61af66fc99e Initial load duke parents: diff changeset	37 // support is provided. Allocation by the interpreter and compiled code is done inline
a61af66fc99e Initial load duke parents: diff changeset	38 // and bails out to Scavenge::invoke_and_allocate.
a61af66fc99e Initial load duke parents: diff changeset	39
a61af66fc99e Initial load duke parents: diff changeset	40 class CollectedHeap;
a61af66fc99e Initial load duke parents: diff changeset	41 class DeferredObjAllocEvent;
a61af66fc99e Initial load duke parents: diff changeset	42
a61af66fc99e Initial load duke parents: diff changeset	43
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	44 // A helper class for caching a Method* when the user of the cache
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	45 // only cares about the latest version of the Method*. This cache safely
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	46 // interacts with the RedefineClasses API.
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	47
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	48 class LatestMethodCache : public CHeapObj<mtClass> {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	49 // We save the Klass* and the idnum of Method* in order to get
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	50 // the current cached Method*.
0 a61af66fc99e Initial load duke parents: diff changeset	51 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	52 Klass* _klass;
0 a61af66fc99e Initial load duke parents: diff changeset	53 int _method_idnum;
a61af66fc99e Initial load duke parents: diff changeset	54
a61af66fc99e Initial load duke parents: diff changeset	55 public:
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	56 LatestMethodCache() { _klass = NULL; _method_idnum = -1; }
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	57 ~LatestMethodCache() { _klass = NULL; _method_idnum = -1; }
0 a61af66fc99e Initial load duke parents: diff changeset	58
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	59 void init(Klass* k, Method* m);
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	60 Klass* klass() const { return _klass; }
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	61 int method_idnum() const { return _method_idnum; }
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	62
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	63 Method* get_method();
0 a61af66fc99e Initial load duke parents: diff changeset	64
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	65 // Enhanced Class Redefinition support
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	66 void classes_do(void f(Klass*)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	67 f(_klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	68 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	69
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	70 // CDS support. Replace the klass in this with the archive version
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	71 // could use this for Enhanced Class Redefinition also.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	72 void serialize(SerializeClosure* f) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	73 f->do_ptr((void**)&_klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	74 }
0 a61af66fc99e Initial load duke parents: diff changeset	75 };
a61af66fc99e Initial load duke parents: diff changeset	76
a61af66fc99e Initial load duke parents: diff changeset	77
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	78 // For UseCompressedOops.
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	79 struct NarrowPtrStruct {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	80 // Base address for oop-within-java-object materialization.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	81 // NULL if using wide oops or zero based narrow oops.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	82 address _base;
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	83 // Number of shift bits for encoding/decoding narrow ptrs.
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	84 // 0 if using wide ptrs or zero based unscaled narrow ptrs,
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	85 // LogMinObjAlignmentInBytes/LogKlassAlignmentInBytes otherwise.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	86 int _shift;
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	87 // Generate code with implicit null checks for narrow ptrs.
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	88 bool _use_implicit_null_checks;
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	89 };
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	90
3772 6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	91 enum VerifyOption {
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	92 VerifyOption_Default = 0,
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	93
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	94 // G1
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	95 VerifyOption_G1UsePrevMarking = VerifyOption_Default,
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	96 VerifyOption_G1UseNextMarking = VerifyOption_G1UsePrevMarking + 1,
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	97 VerifyOption_G1UseMarkWord = VerifyOption_G1UseNextMarking + 1
6747fd0512e0 7004681: G1: Extend marking verification to Full GCs johnc parents: 2426 diff changeset	98 };
0 a61af66fc99e Initial load duke parents: diff changeset	99
a61af66fc99e Initial load duke parents: diff changeset	100 class Universe: AllStatic {
481 7d7a7c599c17 6578152: fill_region_with_object has usability and safety issues jcoomes parents: 196 diff changeset	101 // Ugh. Universe is much too friendly.
0 a61af66fc99e Initial load duke parents: diff changeset	102 friend class MarkSweep;
a61af66fc99e Initial load duke parents: diff changeset	103 friend class oopDesc;
a61af66fc99e Initial load duke parents: diff changeset	104 friend class ClassLoader;
a61af66fc99e Initial load duke parents: diff changeset	105 friend class Arguments;
a61af66fc99e Initial load duke parents: diff changeset	106 friend class SystemDictionary;
a61af66fc99e Initial load duke parents: diff changeset	107 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	108 friend class VM_PopulateDumpSharedSpace;
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 12022 diff changeset	109 friend class Metaspace;
0 a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 friend jint universe_init();
a61af66fc99e Initial load duke parents: diff changeset	112 friend void universe2_init();
a61af66fc99e Initial load duke parents: diff changeset	113 friend bool universe_post_init();
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 private:
a61af66fc99e Initial load duke parents: diff changeset	116 // Known classes in the VM
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	117 static Klass* _boolArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	118 static Klass* _byteArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	119 static Klass* _charArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	120 static Klass* _intArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	121 static Klass* _shortArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	122 static Klass* _longArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	123 static Klass* _singleArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	124 static Klass* _doubleArrayKlassObj;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	125 static Klass* _typeArrayKlassObjs[T_VOID+1];
0 a61af66fc99e Initial load duke parents: diff changeset	126
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	127 static Klass* _objectArrayKlassObj;
0 a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129 // Known objects in the VM
a61af66fc99e Initial load duke parents: diff changeset	130
a61af66fc99e Initial load duke parents: diff changeset	131 // Primitive objects
a61af66fc99e Initial load duke parents: diff changeset	132 static oop _int_mirror;
a61af66fc99e Initial load duke parents: diff changeset	133 static oop _float_mirror;
a61af66fc99e Initial load duke parents: diff changeset	134 static oop _double_mirror;
a61af66fc99e Initial load duke parents: diff changeset	135 static oop _byte_mirror;
a61af66fc99e Initial load duke parents: diff changeset	136 static oop _bool_mirror;
a61af66fc99e Initial load duke parents: diff changeset	137 static oop _char_mirror;
a61af66fc99e Initial load duke parents: diff changeset	138 static oop _long_mirror;
a61af66fc99e Initial load duke parents: diff changeset	139 static oop _short_mirror;
a61af66fc99e Initial load duke parents: diff changeset	140 static oop _void_mirror;
a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 static oop _main_thread_group; // Reference to the main thread group object
a61af66fc99e Initial load duke parents: diff changeset	143 static oop _system_thread_group; // Reference to the system thread group object
a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145 static objArrayOop _the_empty_class_klass_array; // Canonicalized obj array of type java.lang.Class
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 860 diff changeset	146 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	147 static oop _the_min_jint_string; // A cache of "-2147483648" as a Java string
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	148 static LatestMethodCache* _finalizer_register_cache; // static method for registering finalizable objects
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	149 static LatestMethodCache* _loader_addClass_cache; // method for registering loaded classes in class loader vector
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	150 static LatestMethodCache* _pd_implies_cache; // method for checking protection domain attributes
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	151
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10405 diff changeset	152 // preallocated error objects (no backtrace)
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10405 diff changeset	153 static oop _out_of_memory_error_java_heap;
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10405 diff changeset	154 static 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: 10405 diff changeset	155 static oop _out_of_memory_error_class_metaspace;
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10405 diff changeset	156 static oop _out_of_memory_error_array_size;
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10405 diff changeset	157 static oop _out_of_memory_error_gc_overhead_limit;
0 a61af66fc99e Initial load duke parents: diff changeset	158
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	159 static Array<int>* _the_empty_int_array; // Canonicalized int array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	160 static Array<u2>* _the_empty_short_array; // Canonicalized short array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	161 static Array<Klass> _the_empty_klass_array; // Canonicalized klass obj array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	162 static Array<Method> _the_empty_method_array; // Canonicalized method obj array
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	163
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	164 static Array<Klass> _the_array_interfaces_array;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	165
0 a61af66fc99e Initial load duke parents: diff changeset	166 // array of preallocated error objects with backtrace
a61af66fc99e Initial load duke parents: diff changeset	167 static objArrayOop _preallocated_out_of_memory_error_array;
a61af66fc99e Initial load duke parents: diff changeset	168
a61af66fc99e Initial load duke parents: diff changeset	169 // number of preallocated error objects available for use
a61af66fc99e Initial load duke parents: diff changeset	170 static volatile jint _preallocated_out_of_memory_error_avail_count;
a61af66fc99e Initial load duke parents: diff changeset	171
a61af66fc99e Initial load duke parents: diff changeset	172 static oop _null_ptr_exception_instance; // preallocated exception object
a61af66fc99e Initial load duke parents: diff changeset	173 static oop _arithmetic_exception_instance; // preallocated exception object
a61af66fc99e Initial load duke parents: diff changeset	174 static oop _virtual_machine_error_instance; // preallocated exception object
a61af66fc99e Initial load duke parents: diff changeset	175 // The object used as an exception dummy when exceptions are thrown for
a61af66fc99e Initial load duke parents: diff changeset	176 // the vm thread.
a61af66fc99e Initial load duke parents: diff changeset	177 static oop _vm_exception;
a61af66fc99e Initial load duke parents: diff changeset	178
a61af66fc99e Initial load duke parents: diff changeset	179 // The particular choice of collected heap.
a61af66fc99e Initial load duke parents: diff changeset	180 static CollectedHeap* _collectedHeap;
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	181
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 494 diff changeset	182 // For UseCompressedOops.
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	183 static struct NarrowPtrStruct _narrow_oop;
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	184 // For UseCompressedClassPointers.
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	185 static struct NarrowPtrStruct _narrow_klass;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	186 static address _narrow_ptrs_base;
0 a61af66fc99e Initial load duke parents: diff changeset	187
a61af66fc99e Initial load duke parents: diff changeset	188 // array of dummy objects used with +FullGCAlot
a61af66fc99e Initial load duke parents: diff changeset	189 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	190 // index of next entry to clear
0 a61af66fc99e Initial load duke parents: diff changeset	191 debug_only(static int _fullgc_alot_dummy_next;)
a61af66fc99e Initial load duke parents: diff changeset	192
a61af66fc99e Initial load duke parents: diff changeset	193 // Compiler/dispatch support
a61af66fc99e Initial load duke parents: diff changeset	194 static int _base_vtable_size; // Java vtbl size of klass Object (in words)
a61af66fc99e Initial load duke parents: diff changeset	195
a61af66fc99e Initial load duke parents: diff changeset	196 // Initialization
a61af66fc99e Initial load duke parents: diff changeset	197 static bool _bootstrapping; // true during genesis
a61af66fc99e Initial load duke parents: diff changeset	198 static bool _fully_initialized; // true after universe_init and initialize_vtables called
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 // the array of preallocated errors with backtraces
a61af66fc99e Initial load duke parents: diff changeset	201 static objArrayOop preallocated_out_of_memory_errors() { return _preallocated_out_of_memory_error_array; }
a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 // generate an out of memory error; if possible using an error with preallocated backtrace;
a61af66fc99e Initial load duke parents: diff changeset	204 // otherwise return the given default error.
a61af66fc99e Initial load duke parents: diff changeset	205 static oop gen_out_of_memory_error(oop default_err);
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 // Historic gc information
a61af66fc99e Initial load duke parents: diff changeset	208 static size_t _heap_capacity_at_last_gc;
a61af66fc99e Initial load duke parents: diff changeset	209 static size_t _heap_used_at_last_gc;
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 static jint initialize_heap();
a61af66fc99e Initial load duke parents: diff changeset	212 static void initialize_basic_type_mirrors(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	213 static void fixup_mirrors(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215 static void reinitialize_vtable_of(KlassHandle h_k, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	216 static void reinitialize_itables(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	217 static void compute_base_vtable_size(); // compute vtable size of class Object
a61af66fc99e Initial load duke parents: diff changeset	218
a61af66fc99e Initial load duke parents: diff changeset	219 static void genesis(TRAPS); // Create the initial world
a61af66fc99e Initial load duke parents: diff changeset	220
a61af66fc99e Initial load duke parents: diff changeset	221 // Mirrors for primitive classes (created eagerly)
a61af66fc99e Initial load duke parents: diff changeset	222 static oop check_mirror(oop m) {
a61af66fc99e Initial load duke parents: diff changeset	223 assert(m != NULL, "mirror not initialized");
a61af66fc99e Initial load duke parents: diff changeset	224 return m;
a61af66fc99e Initial load duke parents: diff changeset	225 }
a61af66fc99e Initial load duke parents: diff changeset	226
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	227 static void set_narrow_oop_base(address base) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	228 assert(UseCompressedOops, "no compressed oops?");
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	229 _narrow_oop._base = base;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	230 }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	231 static void set_narrow_klass_base(address base) {
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	232 assert(UseCompressedClassPointers, "no compressed klass ptrs?");
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	233 _narrow_klass._base = base;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	234 }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	235 static void set_narrow_oop_use_implicit_null_checks(bool use) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	236 assert(UseCompressedOops, "no compressed ptrs?");
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	237 _narrow_oop._use_implicit_null_checks = use;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	238 }
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6866 diff changeset	239
0 a61af66fc99e Initial load duke parents: diff changeset	240 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	241 static int _verify_count; // number of verifies done
a61af66fc99e Initial load duke parents: diff changeset	242 // True during call to verify(). Should only be set/cleared in verify().
a61af66fc99e Initial load duke parents: diff changeset	243 static bool _verify_in_progress;
a61af66fc99e Initial load duke parents: diff changeset	244
a61af66fc99e Initial load duke parents: diff changeset	245 static void compute_verify_oop_data();
a61af66fc99e Initial load duke parents: diff changeset	246
a61af66fc99e Initial load duke parents: diff changeset	247 public:
a61af66fc99e Initial load duke parents: diff changeset	248 // Known classes in the VM
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	249 static Klass* boolArrayKlassObj() { return _boolArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	250 static Klass* byteArrayKlassObj() { return _byteArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	251 static Klass* charArrayKlassObj() { return _charArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	252 static Klass* intArrayKlassObj() { return _intArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	253 static Klass* shortArrayKlassObj() { return _shortArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	254 static Klass* longArrayKlassObj() { return _longArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	255 static Klass* singleArrayKlassObj() { return _singleArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	256 static Klass* doubleArrayKlassObj() { return _doubleArrayKlassObj; }
0 a61af66fc99e Initial load duke parents: diff changeset	257
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	258 static Klass* objectArrayKlassObj() {
0 a61af66fc99e Initial load duke parents: diff changeset	259 return _objectArrayKlassObj;
a61af66fc99e Initial load duke parents: diff changeset	260 }
a61af66fc99e Initial load duke parents: diff changeset	261
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	262 static Klass* typeArrayKlassObj(BasicType t) {
6182 765ee2d1674b 7157365: jruby/bench.bench_timeout crashes with JVM internal error twisti parents: 6008 diff changeset	263 assert((uint)t < T_VOID+1, err_msg("range check for type: %s", type2name(t)));
0 a61af66fc99e Initial load duke parents: diff changeset	264 assert(_typeArrayKlassObjs[t] != NULL, "domain check");
a61af66fc99e Initial load duke parents: diff changeset	265 return _typeArrayKlassObjs[t];
a61af66fc99e Initial load duke parents: diff changeset	266 }
a61af66fc99e Initial load duke parents: diff changeset	267
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	268 // Known objects in the VM
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	269 static oop int_mirror() { return check_mirror(_int_mirror); }
0 a61af66fc99e Initial load duke parents: diff changeset	270 static oop float_mirror() { return check_mirror(_float_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	271 static oop double_mirror() { return check_mirror(_double_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	272 static oop byte_mirror() { return check_mirror(_byte_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	273 static oop bool_mirror() { return check_mirror(_bool_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	274 static oop char_mirror() { return check_mirror(_char_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	275 static oop long_mirror() { return check_mirror(_long_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	276 static oop short_mirror() { return check_mirror(_short_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	277 static oop void_mirror() { return check_mirror(_void_mirror); }
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 // table of same
a61af66fc99e Initial load duke parents: diff changeset	280 static oop _mirrors[T_VOID+1];
a61af66fc99e Initial load duke parents: diff changeset	281
a61af66fc99e Initial load duke parents: diff changeset	282 static oop java_mirror(BasicType t) {
a61af66fc99e Initial load duke parents: diff changeset	283 assert((uint)t < T_VOID+1, "range check");
a61af66fc99e Initial load duke parents: diff changeset	284 return check_mirror(_mirrors[t]);
a61af66fc99e Initial load duke parents: diff changeset	285 }
a61af66fc99e Initial load duke parents: diff changeset	286 static oop main_thread_group() { return _main_thread_group; }
a61af66fc99e Initial load duke parents: diff changeset	287 static void set_main_thread_group(oop group) { _main_thread_group = group;}
a61af66fc99e Initial load duke parents: diff changeset	288
a61af66fc99e Initial load duke parents: diff changeset	289 static oop system_thread_group() { return _system_thread_group; }
a61af66fc99e Initial load duke parents: diff changeset	290 static void set_system_thread_group(oop group) { _system_thread_group = group;}
a61af66fc99e Initial load duke parents: diff changeset	291
a61af66fc99e Initial load duke parents: diff changeset	292 static objArrayOop the_empty_class_klass_array () { return _the_empty_class_klass_array; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	293 static Array<Klass> the_array_interfaces_array() { return _the_array_interfaces_array; }
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 860 diff changeset	294 static oop the_null_string() { return _the_null_string; }
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 860 diff changeset	295 static oop the_min_jint_string() { return _the_min_jint_string; }
11010 b295e132102d 8001330: Improve on checking order mullan parents: 7982 diff changeset	296
12022 85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	297 static Method* finalizer_register_method() { return _finalizer_register_cache->get_method(); }
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	298 static Method* loader_addClass_method() { return _loader_addClass_cache->get_method(); }
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	299
85147f28faba 8009728: nsk/jvmti/AttachOnDemand/attach030 crashes on Win32 coleenp parents: 11065 diff changeset	300 static Method* protection_domain_implies_method() { return _pd_implies_cache->get_method(); }
11010 b295e132102d 8001330: Improve on checking order mullan parents: 7982 diff changeset	301
0 a61af66fc99e Initial load duke parents: diff changeset	302 static oop null_ptr_exception_instance() { return _null_ptr_exception_instance; }
a61af66fc99e Initial load duke parents: diff changeset	303 static oop arithmetic_exception_instance() { return _arithmetic_exception_instance; }
a61af66fc99e Initial load duke parents: diff changeset	304 static oop virtual_machine_error_instance() { return _virtual_machine_error_instance; }
a61af66fc99e Initial load duke parents: diff changeset	305 static oop vm_exception() { return _vm_exception; }
a61af66fc99e Initial load duke parents: diff changeset	306
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	307 static Array<int>* the_empty_int_array() { return _the_empty_int_array; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	308 static Array<u2>* the_empty_short_array() { return _the_empty_short_array; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	309 static Array<Method> the_empty_method_array() { return _the_empty_method_array; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	310 static Array<Klass> the_empty_klass_array() { return _the_empty_klass_array; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	311
0 a61af66fc99e Initial load duke parents: diff changeset	312 // OutOfMemoryError support. Returns an error with the required message. The returned error
a61af66fc99e Initial load duke parents: diff changeset	313 // may or may not have a backtrace. If error has a backtrace then the stack trace is already
a61af66fc99e Initial load duke parents: diff changeset	314 // filled in.
a61af66fc99e Initial load duke parents: diff changeset	315 static oop out_of_memory_error_java_heap() { return gen_out_of_memory_error(_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: 10405 diff changeset	316 static oop out_of_memory_error_metaspace() { return gen_out_of_memory_error(_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: 10405 diff changeset	317 static oop out_of_memory_error_class_metaspace() { return gen_out_of_memory_error(_out_of_memory_error_class_metaspace); }
0 a61af66fc99e Initial load duke parents: diff changeset	318 static oop out_of_memory_error_array_size() { return gen_out_of_memory_error(_out_of_memory_error_array_size); }
a61af66fc99e Initial load duke parents: diff changeset	319 static oop out_of_memory_error_gc_overhead_limit() { return gen_out_of_memory_error(_out_of_memory_error_gc_overhead_limit); }
a61af66fc99e Initial load duke parents: diff changeset	320
a61af66fc99e Initial load duke parents: diff changeset	321 // Accessors needed for fast allocation
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	322 static Klass** boolArrayKlassObj_addr() { return &_boolArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	323 static Klass** byteArrayKlassObj_addr() { return &_byteArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	324 static Klass** charArrayKlassObj_addr() { return &_charArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	325 static Klass** intArrayKlassObj_addr() { return &_intArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	326 static Klass** shortArrayKlassObj_addr() { return &_shortArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	327 static Klass** longArrayKlassObj_addr() { return &_longArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	328 static Klass** singleArrayKlassObj_addr() { return &_singleArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	329 static Klass** doubleArrayKlassObj_addr() { return &_doubleArrayKlassObj; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	330 static Klass** objectArrayKlassObj_addr() { return &_objectArrayKlassObj; }
0 a61af66fc99e Initial load duke parents: diff changeset	331
a61af66fc99e Initial load duke parents: diff changeset	332 // The particular choice of collected heap.
a61af66fc99e Initial load duke parents: diff changeset	333 static CollectedHeap* heap() { return _collectedHeap; }
a61af66fc99e Initial load duke parents: diff changeset	334
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	335 // For UseCompressedOops
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	336 // Narrow Oop encoding mode:
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	337 // 0 - Use 32-bits oops without encoding when
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	338 // NarrowOopHeapBaseMin + heap_size < 4Gb
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	339 // 1 - Use zero based compressed oops with encoding when
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	340 // NarrowOopHeapBaseMin + heap_size < 32Gb
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	341 // 2 - Use compressed oops with heap base + encoding.
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	342 enum NARROW_OOP_MODE {
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	343 UnscaledNarrowOop = 0,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	344 ZeroBasedNarrowOop = 1,
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	345 HeapBasedNarrowOop = 2
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	346 };
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	347 static NARROW_OOP_MODE narrow_oop_mode();
f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	348 static const char* narrow_oop_mode_to_string(NARROW_OOP_MODE mode);
12110 4c84d351cca9 8007074: SIGSEGV at ParMarkBitMap::verify_clear() stefank parents: 12056 diff changeset	349 static char* preferred_heap_base(size_t heap_size, size_t alignment, NARROW_OOP_MODE mode);
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10265 diff changeset	350 static char* preferred_metaspace_base(size_t heap_size, NARROW_OOP_MODE mode);
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	351 static address narrow_oop_base() { return _narrow_oop._base; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	352 static bool is_narrow_oop_base(void* addr) { return (narrow_oop_base() == (address)addr); }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	353 static int narrow_oop_shift() { return _narrow_oop._shift; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	354 static bool narrow_oop_use_implicit_null_checks() { return _narrow_oop._use_implicit_null_checks; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	355
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	356 // For UseCompressedClassPointers
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	357 static address narrow_klass_base() { return _narrow_klass._base; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	358 static bool is_narrow_klass_base(void* addr) { return (narrow_klass_base() == (address)addr); }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	359 static int narrow_klass_shift() { return _narrow_klass._shift; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	360 static bool narrow_klass_use_implicit_null_checks() { return _narrow_klass._use_implicit_null_checks; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	361
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	362 static address* narrow_ptrs_base_addr() { return &_narrow_ptrs_base; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	363 static void set_narrow_ptrs_base(address a) { _narrow_ptrs_base = a; }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	364 static address narrow_ptrs_base() { return _narrow_ptrs_base; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	365
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	366 // this is set in vm_version on sparc (and then reset in universe afaict)
6848 8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	367 static void set_narrow_oop_shift(int shift) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	368 _narrow_oop._shift = shift;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	369 }
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	370
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	371 static void set_narrow_klass_shift(int shift) {
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	372 assert(shift == 0 \|\| shift == LogKlassAlignmentInBytes, "invalid shift for klass ptrs");
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	373 _narrow_klass._shift = shift;
8e47bac5643a 7054512: Compress class pointers after perm gen removal roland parents: 6751 diff changeset	374 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	375
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	376 // Reserve Java heap and determine CompressedOops mode
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	377 static ReservedSpace reserve_heap(size_t heap_size, size_t alignment);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	378
0 a61af66fc99e Initial load duke parents: diff changeset	379 // Historic gc information
a61af66fc99e Initial load duke parents: diff changeset	380 static size_t get_heap_capacity_at_last_gc() { return _heap_capacity_at_last_gc; }
a61af66fc99e Initial load duke parents: diff changeset	381 static size_t get_heap_free_at_last_gc() { return _heap_capacity_at_last_gc - _heap_used_at_last_gc; }
a61af66fc99e Initial load duke parents: diff changeset	382 static size_t get_heap_used_at_last_gc() { return _heap_used_at_last_gc; }
a61af66fc99e Initial load duke parents: diff changeset	383 static void update_heap_info_at_gc();
a61af66fc99e Initial load duke parents: diff changeset	384
a61af66fc99e Initial load duke parents: diff changeset	385 // Testers
a61af66fc99e Initial load duke parents: diff changeset	386 static bool is_bootstrapping() { return _bootstrapping; }
a61af66fc99e Initial load duke parents: diff changeset	387 static bool is_fully_initialized() { return _fully_initialized; }
a61af66fc99e Initial load duke parents: diff changeset	388
a61af66fc99e Initial load duke parents: diff changeset	389 static inline bool element_type_should_be_aligned(BasicType type);
a61af66fc99e Initial load duke parents: diff changeset	390 static inline bool field_type_should_be_aligned(BasicType type);
a61af66fc99e Initial load duke parents: diff changeset	391 static bool on_page_boundary(void* addr);
a61af66fc99e Initial load duke parents: diff changeset	392 static bool should_fill_in_stack_trace(Handle throwable);
a61af66fc99e Initial load duke parents: diff changeset	393 static void check_alignment(uintx size, uintx alignment, const char* name);
a61af66fc99e Initial load duke parents: diff changeset	394
a61af66fc99e Initial load duke parents: diff changeset	395 // Finalizer support.
a61af66fc99e Initial load duke parents: diff changeset	396 static void run_finalizers_on_exit();
a61af66fc99e Initial load duke parents: diff changeset	397
a61af66fc99e Initial load duke parents: diff changeset	398 // Iteration
a61af66fc99e Initial load duke parents: diff changeset	399
a61af66fc99e Initial load duke parents: diff changeset	400 // Apply "f" to the addresses of all the direct heap pointers maintained
a61af66fc99e Initial load duke parents: diff changeset	401 // as static fields of "Universe".
a61af66fc99e Initial load duke parents: diff changeset	402 static void oops_do(OopClosure* f, bool do_all = false);
a61af66fc99e Initial load duke parents: diff changeset	403
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	404 // CDS support
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	405 static void serialize(SerializeClosure* f, bool do_all = false);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	406
0 a61af66fc99e Initial load duke parents: diff changeset	407 // Apply "f" to all klasses for basic types (classes not present in
a61af66fc99e Initial load duke parents: diff changeset	408 // SystemDictionary).
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6198 diff changeset	409 static void basic_type_classes_do(void f(Klass*));
0 a61af66fc99e Initial load duke parents: diff changeset	410
a61af66fc99e Initial load duke parents: diff changeset	411 // For sharing -- fill in a list of known vtable pointers.
a61af66fc99e Initial load duke parents: diff changeset	412 static void init_self_patching_vtbl_list(void** list, int count);
a61af66fc99e Initial load duke parents: diff changeset	413
a61af66fc99e Initial load duke parents: diff changeset	414 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	415 static bool verify_in_progress() { return _verify_in_progress; }
10186 b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	416 static void verify(VerifyOption option, const char* prefix, bool silent = VerifySilently);
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	417 static void verify(const char* prefix, bool silent = VerifySilently) {
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	418 verify(VerifyOption_Default, prefix, silent);
6865 4202510ee0fe 8000831: Heap verification output incorrect/incomplete johnc parents: 6751 diff changeset	419 }
10186 b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	420 static void verify(bool silent = VerifySilently) {
b06ac540229e 8013132: Add a flag to turn off the output of the verbose verification code stefank parents: 7982 diff changeset	421 verify("", silent);
6865 4202510ee0fe 8000831: Heap verification output incorrect/incomplete johnc parents: 6751 diff changeset	422 }
4202510ee0fe 8000831: Heap verification output incorrect/incomplete johnc parents: 6751 diff changeset	423
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	424 static int verify_count() { return _verify_count; }
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	425 // The default behavior is to call print_on() on gclog_or_tty.
0 a61af66fc99e Initial load duke parents: diff changeset	426 static void print();
4073 53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	427 // The extended parameter determines which method on the heap will
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	428 // be called: print_on() (extended == false) or print_extended_on()
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	429 // (extended == true).
53074c2c4600 7099849: G1: include heap region information in hs_err files tonyp parents: 3852 diff changeset	430 static void print_on(outputStream* st, bool extended = false);
0 a61af66fc99e Initial load duke parents: diff changeset	431 static void print_heap_at_SIGBREAK();
a61af66fc99e Initial load duke parents: diff changeset	432 static void print_heap_before_gc() { print_heap_before_gc(gclog_or_tty); }
a61af66fc99e Initial load duke parents: diff changeset	433 static void print_heap_after_gc() { print_heap_after_gc(gclog_or_tty); }
4944 09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4073 diff changeset	434 static void print_heap_before_gc(outputStream* st, bool ignore_extended = false);
09d00c18e323 7145537: minor tweaks to LogEvents never parents: 4073 diff changeset	435 static void print_heap_after_gc(outputStream* st, bool ignore_extended = false);
0 a61af66fc99e Initial load duke parents: diff changeset	436
a61af66fc99e Initial load duke parents: diff changeset	437 // Change the number of dummy objects kept reachable by the full gc dummy
a61af66fc99e Initial load duke parents: diff changeset	438 // array; this should trigger relocation in a sliding compaction collector.
a61af66fc99e Initial load duke parents: diff changeset	439 debug_only(static bool release_fullgc_alot_dummy();)
a61af66fc99e Initial load duke parents: diff changeset	440 // The non-oop pattern (see compiledIC.hpp, etc)
a61af66fc99e Initial load duke parents: diff changeset	441 static void* non_oop_word();
a61af66fc99e Initial load duke parents: diff changeset	442
a61af66fc99e Initial load duke parents: diff changeset	443 // Oop verification (see MacroAssembler::verify_oop)
a61af66fc99e Initial load duke parents: diff changeset	444 static uintptr_t verify_oop_mask() PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	445 static uintptr_t verify_oop_bits() PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	446 static uintptr_t verify_mark_bits() PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	447 static uintptr_t verify_mark_mask() PRODUCT_RETURN0;
a61af66fc99e Initial load duke parents: diff changeset	448
a61af66fc99e Initial load duke parents: diff changeset	449 // Flushing and deoptimization
a61af66fc99e Initial load duke parents: diff changeset	450 static void flush_dependents_on(instanceKlassHandle dependee);
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 3772 diff changeset	451 static void flush_dependents_on(Handle call_site, Handle method_handle);
0 a61af66fc99e Initial load duke parents: diff changeset	452 #ifdef HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	453 // Flushing and deoptimization in case of evolution
a61af66fc99e Initial load duke parents: diff changeset	454 static void flush_evol_dependents_on(instanceKlassHandle dependee);
a61af66fc99e Initial load duke parents: diff changeset	455 #endif // HOTSWAP
a61af66fc99e Initial load duke parents: diff changeset	456 // Support for fullspeed debugging
a61af66fc99e Initial load duke parents: diff changeset	457 static void flush_dependents_on_method(methodHandle dependee);
a61af66fc99e Initial load duke parents: diff changeset	458
a61af66fc99e Initial load duke parents: diff changeset	459 // Compiler support
a61af66fc99e Initial load duke parents: diff changeset	460 static int base_vtable_size() { return _base_vtable_size; }
a61af66fc99e Initial load duke parents: diff changeset	461 };
a61af66fc99e Initial load duke parents: diff changeset	462
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6008 diff changeset	463 class DeferredObjAllocEvent : public CHeapObj<mtInternal> {
0 a61af66fc99e Initial load duke parents: diff changeset	464 private:
a61af66fc99e Initial load duke parents: diff changeset	465 oop _oop;
a61af66fc99e Initial load duke parents: diff changeset	466 size_t _bytesize;
a61af66fc99e Initial load duke parents: diff changeset	467 jint _arena_id;
a61af66fc99e Initial load duke parents: diff changeset	468
a61af66fc99e Initial load duke parents: diff changeset	469 public:
a61af66fc99e Initial load duke parents: diff changeset	470 DeferredObjAllocEvent(const oop o, const size_t s, const jint id) {
a61af66fc99e Initial load duke parents: diff changeset	471 _oop = o;
a61af66fc99e Initial load duke parents: diff changeset	472 _bytesize = s;
a61af66fc99e Initial load duke parents: diff changeset	473 _arena_id = id;
a61af66fc99e Initial load duke parents: diff changeset	474 }
a61af66fc99e Initial load duke parents: diff changeset	475
a61af66fc99e Initial load duke parents: diff changeset	476 ~DeferredObjAllocEvent() {
a61af66fc99e Initial load duke parents: diff changeset	477 }
a61af66fc99e Initial load duke parents: diff changeset	478
a61af66fc99e Initial load duke parents: diff changeset	479 jint arena_id() { return _arena_id; }
a61af66fc99e Initial load duke parents: diff changeset	480 size_t bytesize() { return _bytesize; }
a61af66fc99e Initial load duke parents: diff changeset	481 oop get_oop() { return _oop; }
a61af66fc99e Initial load duke parents: diff changeset	482 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	483
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1913 diff changeset	484 #endif // SHARE_VM_MEMORY_UNIVERSE_HPP

Mercurial > hg > graal-jvmci-8

annotate src/share/vm/memory/universe.hpp @ 12233:40136aa2cdb1