Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/reflectionUtils.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 /* |
| 1972 | 2 * Copyright (c) 1999, 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:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
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:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_RUNTIME_REFLECTIONUTILS_HPP |
| 26 #define SHARE_VM_RUNTIME_REFLECTIONUTILS_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
| 29 #include "oops/instanceKlass.hpp" | |
| 30 #include "oops/objArrayOop.hpp" | |
| 31 #include "oops/oopsHierarchy.hpp" | |
| 32 #include "runtime/handles.inline.hpp" | |
| 33 #include "runtime/reflection.hpp" | |
| 34 #include "utilities/accessFlags.hpp" | |
| 35 #include "utilities/globalDefinitions.hpp" | |
| 36 | |
| 0 | 37 // A KlassStream is an abstract stream for streaming over self, superclasses |
| 38 // and (super)interfaces. Streaming is done in reverse order (subclasses first, | |
| 39 // interfaces last). | |
| 40 // | |
| 41 // for (KlassStream st(k, false, false); !st.eos(); st.next()) { | |
| 42 // klassOop k = st.klass(); | |
| 43 // ... | |
| 44 // } | |
| 45 | |
| 46 class KlassStream VALUE_OBJ_CLASS_SPEC { | |
| 47 protected: | |
| 48 instanceKlassHandle _klass; // current klass/interface iterated over | |
| 49 objArrayHandle _interfaces; // transitive interfaces for initial class | |
| 50 int _interface_index; // current interface being processed | |
| 51 bool _local_only; // process initial class/interface only | |
| 52 bool _classes_only; // process classes only (no interfaces) | |
| 53 int _index; | |
| 54 | |
| 55 virtual int length() const = 0; | |
| 56 | |
| 57 public: | |
| 58 // constructor | |
| 59 KlassStream(instanceKlassHandle klass, bool local_only, bool classes_only); | |
| 60 | |
| 61 // testing | |
| 62 bool eos(); | |
| 63 | |
| 64 // iterating | |
| 65 virtual void next() = 0; | |
| 66 | |
| 67 // accessors | |
| 68 instanceKlassHandle klass() const { return _klass; } | |
| 69 int index() const { return _index; } | |
| 70 }; | |
| 71 | |
| 72 | |
| 73 // A MethodStream streams over all methods in a class, superclasses and (super)interfaces. | |
| 74 // Streaming is done in reverse order (subclasses first, methods in reverse order) | |
| 75 // Usage: | |
| 76 // | |
| 77 // for (MethodStream st(k, false, false); !st.eos(); st.next()) { | |
| 78 // methodOop m = st.method(); | |
| 79 // ... | |
| 80 // } | |
| 81 | |
| 82 class MethodStream : public KlassStream { | |
| 83 private: | |
| 84 int length() const { return methods()->length(); } | |
| 85 objArrayOop methods() const { return _klass->methods(); } | |
| 86 public: | |
| 87 MethodStream(instanceKlassHandle klass, bool local_only, bool classes_only) | |
| 88 : KlassStream(klass, local_only, classes_only) { | |
| 89 _index = length(); | |
| 90 next(); | |
| 91 } | |
| 92 | |
| 93 void next() { _index--; } | |
| 94 methodOop method() const { return methodOop(methods()->obj_at(index())); } | |
| 95 }; | |
| 96 | |
| 97 | |
| 98 // A FieldStream streams over all fields in a class, superclasses and (super)interfaces. | |
| 99 // Streaming is done in reverse order (subclasses first, fields in reverse order) | |
| 100 // Usage: | |
| 101 // | |
| 102 // for (FieldStream st(k, false, false); !st.eos(); st.next()) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
103 // Symbol* field_name = st.name(); |
| 0 | 104 // ... |
| 105 // } | |
| 106 | |
| 107 | |
| 108 class FieldStream : public KlassStream { | |
| 109 private: | |
| 110 int length() const { return fields()->length(); } | |
| 111 constantPoolOop constants() const { return _klass->constants(); } | |
| 112 protected: | |
| 113 typeArrayOop fields() const { return _klass->fields(); } | |
| 114 public: | |
| 115 FieldStream(instanceKlassHandle klass, bool local_only, bool classes_only) | |
| 116 : KlassStream(klass, local_only, classes_only) { | |
| 117 _index = length(); | |
| 118 next(); | |
| 119 } | |
| 120 | |
| 121 void next() { _index -= instanceKlass::next_offset; } | |
| 122 | |
| 123 // Accessors for current field | |
| 124 AccessFlags access_flags() const { | |
| 125 AccessFlags flags; | |
| 126 flags.set_flags(fields()->ushort_at(index() + instanceKlass::access_flags_offset)); | |
| 127 return flags; | |
| 128 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
129 Symbol* name() const { |
| 0 | 130 int name_index = fields()->ushort_at(index() + instanceKlass::name_index_offset); |
| 131 return constants()->symbol_at(name_index); | |
| 132 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
133 Symbol* signature() const { |
| 0 | 134 int signature_index = fields()->ushort_at(index() + |
| 135 instanceKlass::signature_index_offset); | |
| 136 return constants()->symbol_at(signature_index); | |
| 137 } | |
| 138 // missing: initval() | |
| 139 int offset() const { | |
| 140 return _klass->offset_from_fields( index() ); | |
| 141 } | |
| 142 }; | |
| 143 | |
| 144 class FilteredField { | |
| 145 private: | |
| 146 klassOop _klass; | |
| 147 int _field_offset; | |
| 148 | |
| 149 public: | |
| 150 FilteredField(klassOop klass, int field_offset) { | |
| 151 _klass = klass; | |
| 152 _field_offset = field_offset; | |
| 153 } | |
| 154 klassOop klass() { return _klass; } | |
| 155 oop* klass_addr() { return (oop*) &_klass; } | |
| 156 int field_offset() { return _field_offset; } | |
| 157 }; | |
| 158 | |
| 159 class FilteredFieldsMap : AllStatic { | |
| 160 private: | |
| 161 static GrowableArray<FilteredField *> *_filtered_fields; | |
| 162 public: | |
| 163 static void initialize(); | |
| 164 static bool is_filtered_field(klassOop klass, int field_offset) { | |
| 165 for (int i=0; i < _filtered_fields->length(); i++) { | |
| 166 if (klass == _filtered_fields->at(i)->klass() && | |
| 167 field_offset == _filtered_fields->at(i)->field_offset()) { | |
| 168 return true; | |
| 169 } | |
| 170 } | |
| 171 return false; | |
| 172 } | |
| 173 static int filtered_fields_count(klassOop klass, bool local_only) { | |
| 174 int nflds = 0; | |
| 175 for (int i=0; i < _filtered_fields->length(); i++) { | |
| 176 if (local_only && klass == _filtered_fields->at(i)->klass()) { | |
| 177 nflds++; | |
| 178 } else if (klass->klass_part()->is_subtype_of(_filtered_fields->at(i)->klass())) { | |
| 179 nflds++; | |
| 180 } | |
| 181 } | |
| 182 return nflds; | |
| 183 } | |
| 184 // GC support. | |
| 185 static void klasses_oops_do(OopClosure* f) { | |
| 186 for (int i = 0; i < _filtered_fields->length(); i++) { | |
| 187 f->do_oop((oop*)_filtered_fields->at(i)->klass_addr()); | |
| 188 } | |
| 189 } | |
| 190 }; | |
| 191 | |
| 192 | |
| 193 // A FilteredFieldStream streams over all fields in a class, superclasses and | |
| 194 // (super)interfaces. Streaming is done in reverse order (subclasses first, | |
| 195 // fields in reverse order) | |
| 196 // | |
| 197 // Usage: | |
| 198 // | |
| 199 // for (FilteredFieldStream st(k, false, false); !st.eos(); st.next()) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
200 // Symbol* field_name = st.name(); |
| 0 | 201 // ... |
| 202 // } | |
| 203 | |
| 204 class FilteredFieldStream : public FieldStream { | |
| 205 private: | |
| 206 int _filtered_fields_count; | |
| 207 bool has_filtered_field() { return (_filtered_fields_count > 0); } | |
| 208 | |
| 209 public: | |
| 210 FilteredFieldStream(instanceKlassHandle klass, bool local_only, bool classes_only) | |
| 211 : FieldStream(klass, local_only, classes_only) { | |
| 212 _filtered_fields_count = FilteredFieldsMap::filtered_fields_count((klassOop)klass(), local_only); | |
| 213 } | |
| 214 int field_count(); | |
| 215 void next() { | |
| 216 _index -= instanceKlass::next_offset; | |
| 217 if (has_filtered_field()) { | |
| 218 while (_index >=0 && FilteredFieldsMap::is_filtered_field((klassOop)_klass(), offset())) { | |
| 219 _index -= instanceKlass::next_offset; | |
| 220 } | |
| 221 } | |
| 222 } | |
| 223 }; | |
| 1972 | 224 |
| 225 #endif // SHARE_VM_RUNTIME_REFLECTIONUTILS_HPP |