Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/heapInspection.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
author | ysr |
---|---|
date | Tue, 07 Dec 2010 21:55:53 -0800 |
parents | f95d63e2154a |
children | 3582bf76420e |
rev | line source |
---|---|
0 | 1 /* |
1972 | 2 * Copyright (c) 2002, 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:
1489
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1489
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:
1489
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #include "precompiled.hpp" |
26 #include "gc_interface/collectedHeap.hpp" | |
27 #include "memory/genCollectedHeap.hpp" | |
28 #include "memory/heapInspection.hpp" | |
29 #include "memory/resourceArea.hpp" | |
30 #include "oops/klassOop.hpp" | |
31 #include "runtime/os.hpp" | |
32 #include "utilities/globalDefinitions.hpp" | |
33 #ifndef SERIALGC | |
34 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp" | |
35 #endif | |
0 | 36 |
37 // HeapInspection | |
38 | |
39 int KlassInfoEntry::compare(KlassInfoEntry* e1, KlassInfoEntry* e2) { | |
40 if(e1->_instance_words > e2->_instance_words) { | |
41 return -1; | |
42 } else if(e1->_instance_words < e2->_instance_words) { | |
43 return 1; | |
44 } | |
45 return 0; | |
46 } | |
47 | |
48 void KlassInfoEntry::print_on(outputStream* st) const { | |
49 ResourceMark rm; | |
50 const char* name;; | |
51 if (_klass->klass_part()->name() != NULL) { | |
52 name = _klass->klass_part()->external_name(); | |
53 } else { | |
54 if (_klass == Universe::klassKlassObj()) name = "<klassKlass>"; else | |
55 if (_klass == Universe::arrayKlassKlassObj()) name = "<arrayKlassKlass>"; else | |
56 if (_klass == Universe::objArrayKlassKlassObj()) name = "<objArrayKlassKlass>"; else | |
57 if (_klass == Universe::instanceKlassKlassObj()) name = "<instanceKlassKlass>"; else | |
58 if (_klass == Universe::typeArrayKlassKlassObj()) name = "<typeArrayKlassKlass>"; else | |
59 if (_klass == Universe::symbolKlassObj()) name = "<symbolKlass>"; else | |
60 if (_klass == Universe::boolArrayKlassObj()) name = "<boolArrayKlass>"; else | |
61 if (_klass == Universe::charArrayKlassObj()) name = "<charArrayKlass>"; else | |
62 if (_klass == Universe::singleArrayKlassObj()) name = "<singleArrayKlass>"; else | |
63 if (_klass == Universe::doubleArrayKlassObj()) name = "<doubleArrayKlass>"; else | |
64 if (_klass == Universe::byteArrayKlassObj()) name = "<byteArrayKlass>"; else | |
65 if (_klass == Universe::shortArrayKlassObj()) name = "<shortArrayKlass>"; else | |
66 if (_klass == Universe::intArrayKlassObj()) name = "<intArrayKlass>"; else | |
67 if (_klass == Universe::longArrayKlassObj()) name = "<longArrayKlass>"; else | |
68 if (_klass == Universe::methodKlassObj()) name = "<methodKlass>"; else | |
69 if (_klass == Universe::constMethodKlassObj()) name = "<constMethodKlass>"; else | |
70 if (_klass == Universe::methodDataKlassObj()) name = "<methodDataKlass>"; else | |
71 if (_klass == Universe::constantPoolKlassObj()) name = "<constantPoolKlass>"; else | |
72 if (_klass == Universe::constantPoolCacheKlassObj()) name = "<constantPoolCacheKlass>"; else | |
73 if (_klass == Universe::compiledICHolderKlassObj()) name = "<compiledICHolderKlass>"; else | |
74 name = "<no name>"; | |
75 } | |
76 // simplify the formatting (ILP32 vs LP64) - always cast the numbers to 64-bit | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
77 st->print_cr(INT64_FORMAT_W(13) " " UINT64_FORMAT_W(13) " %s", |
0 | 78 (jlong) _instance_count, |
79 (julong) _instance_words * HeapWordSize, | |
80 name); | |
81 } | |
82 | |
83 KlassInfoEntry* KlassInfoBucket::lookup(const klassOop k) { | |
84 KlassInfoEntry* elt = _list; | |
85 while (elt != NULL) { | |
86 if (elt->is_equal(k)) { | |
87 return elt; | |
88 } | |
89 elt = elt->next(); | |
90 } | |
91 elt = new KlassInfoEntry(k, list()); | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
92 // We may be out of space to allocate the new entry. |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
93 if (elt != NULL) { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
94 set_list(elt); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
95 } |
0 | 96 return elt; |
97 } | |
98 | |
99 void KlassInfoBucket::iterate(KlassInfoClosure* cic) { | |
100 KlassInfoEntry* elt = _list; | |
101 while (elt != NULL) { | |
102 cic->do_cinfo(elt); | |
103 elt = elt->next(); | |
104 } | |
105 } | |
106 | |
107 void KlassInfoBucket::empty() { | |
108 KlassInfoEntry* elt = _list; | |
109 _list = NULL; | |
110 while (elt != NULL) { | |
111 KlassInfoEntry* next = elt->next(); | |
112 delete elt; | |
113 elt = next; | |
114 } | |
115 } | |
116 | |
117 KlassInfoTable::KlassInfoTable(int size, HeapWord* ref) { | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
118 _size = 0; |
0 | 119 _ref = ref; |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
120 _buckets = NEW_C_HEAP_ARRAY(KlassInfoBucket, size); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
121 if (_buckets != NULL) { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
122 _size = size; |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
123 for (int index = 0; index < _size; index++) { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
124 _buckets[index].initialize(); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
125 } |
0 | 126 } |
127 } | |
128 | |
129 KlassInfoTable::~KlassInfoTable() { | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
130 if (_buckets != NULL) { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
131 for (int index = 0; index < _size; index++) { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
132 _buckets[index].empty(); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
133 } |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
134 FREE_C_HEAP_ARRAY(KlassInfoBucket, _buckets); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
135 _size = 0; |
0 | 136 } |
137 } | |
138 | |
139 uint KlassInfoTable::hash(klassOop p) { | |
140 assert(Universe::heap()->is_in_permanent((HeapWord*)p), "all klasses in permgen"); | |
141 return (uint)(((uintptr_t)p - (uintptr_t)_ref) >> 2); | |
142 } | |
143 | |
144 KlassInfoEntry* KlassInfoTable::lookup(const klassOop k) { | |
145 uint idx = hash(k) % _size; | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
146 assert(_buckets != NULL, "Allocation failure should have been caught"); |
0 | 147 KlassInfoEntry* e = _buckets[idx].lookup(k); |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
148 // Lookup may fail if this is a new klass for which we |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
149 // could not allocate space for an new entry. |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
150 assert(e == NULL || k == e->klass(), "must be equal"); |
0 | 151 return e; |
152 } | |
153 | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
154 // Return false if the entry could not be recorded on account |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
155 // of running out of space required to create a new entry. |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
156 bool KlassInfoTable::record_instance(const oop obj) { |
0 | 157 klassOop k = obj->klass(); |
158 KlassInfoEntry* elt = lookup(k); | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
159 // elt may be NULL if it's a new klass for which we |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
160 // could not allocate space for a new entry in the hashtable. |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
161 if (elt != NULL) { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
162 elt->set_count(elt->count() + 1); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
163 elt->set_words(elt->words() + obj->size()); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
164 return true; |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
165 } else { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
166 return false; |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
167 } |
0 | 168 } |
169 | |
170 void KlassInfoTable::iterate(KlassInfoClosure* cic) { | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
171 assert(_size == 0 || _buckets != NULL, "Allocation failure should have been caught"); |
0 | 172 for (int index = 0; index < _size; index++) { |
173 _buckets[index].iterate(cic); | |
174 } | |
175 } | |
176 | |
177 int KlassInfoHisto::sort_helper(KlassInfoEntry** e1, KlassInfoEntry** e2) { | |
178 return (*e1)->compare(*e1,*e2); | |
179 } | |
180 | |
181 KlassInfoHisto::KlassInfoHisto(const char* title, int estimatedCount) : | |
182 _title(title) { | |
183 _elements = new (ResourceObj::C_HEAP) GrowableArray<KlassInfoEntry*>(estimatedCount,true); | |
184 } | |
185 | |
186 KlassInfoHisto::~KlassInfoHisto() { | |
187 delete _elements; | |
188 } | |
189 | |
190 void KlassInfoHisto::add(KlassInfoEntry* cie) { | |
191 elements()->append(cie); | |
192 } | |
193 | |
194 void KlassInfoHisto::sort() { | |
195 elements()->sort(KlassInfoHisto::sort_helper); | |
196 } | |
197 | |
198 void KlassInfoHisto::print_elements(outputStream* st) const { | |
199 // simplify the formatting (ILP32 vs LP64) - store the sum in 64-bit | |
200 jlong total = 0; | |
201 julong totalw = 0; | |
202 for(int i=0; i < elements()->length(); i++) { | |
203 st->print("%4d: ", i+1); | |
204 elements()->at(i)->print_on(st); | |
205 total += elements()->at(i)->count(); | |
206 totalw += elements()->at(i)->words(); | |
207 } | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
208 st->print_cr("Total " INT64_FORMAT_W(13) " " UINT64_FORMAT_W(13), |
0 | 209 total, totalw * HeapWordSize); |
210 } | |
211 | |
212 void KlassInfoHisto::print_on(outputStream* st) const { | |
213 st->print_cr("%s",title()); | |
214 print_elements(st); | |
215 } | |
216 | |
217 class HistoClosure : public KlassInfoClosure { | |
218 private: | |
219 KlassInfoHisto* _cih; | |
220 public: | |
221 HistoClosure(KlassInfoHisto* cih) : _cih(cih) {} | |
222 | |
223 void do_cinfo(KlassInfoEntry* cie) { | |
224 _cih->add(cie); | |
225 } | |
226 }; | |
227 | |
228 class RecordInstanceClosure : public ObjectClosure { | |
229 private: | |
230 KlassInfoTable* _cit; | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
231 size_t _missed_count; |
0 | 232 public: |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
233 RecordInstanceClosure(KlassInfoTable* cit) : |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
234 _cit(cit), _missed_count(0) {} |
0 | 235 |
236 void do_object(oop obj) { | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
237 if (!_cit->record_instance(obj)) { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
238 _missed_count++; |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
239 } |
0 | 240 } |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
241 |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
242 size_t missed_count() { return _missed_count; } |
0 | 243 }; |
244 | |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
517
diff
changeset
|
245 void HeapInspection::heap_inspection(outputStream* st, bool need_prologue) { |
0 | 246 ResourceMark rm; |
247 HeapWord* ref; | |
248 | |
249 CollectedHeap* heap = Universe::heap(); | |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
11
diff
changeset
|
250 bool is_shared_heap = false; |
0 | 251 switch (heap->kind()) { |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
11
diff
changeset
|
252 case CollectedHeap::G1CollectedHeap: |
0 | 253 case CollectedHeap::GenCollectedHeap: { |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
11
diff
changeset
|
254 is_shared_heap = true; |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
11
diff
changeset
|
255 SharedHeap* sh = (SharedHeap*)heap; |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
517
diff
changeset
|
256 if (need_prologue) { |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
517
diff
changeset
|
257 sh->gc_prologue(false /* !full */); // get any necessary locks, etc. |
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
517
diff
changeset
|
258 } |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
11
diff
changeset
|
259 ref = sh->perm_gen()->used_region().start(); |
0 | 260 break; |
261 } | |
262 #ifndef SERIALGC | |
263 case CollectedHeap::ParallelScavengeHeap: { | |
264 ParallelScavengeHeap* psh = (ParallelScavengeHeap*)heap; | |
265 ref = psh->perm_gen()->object_space()->used_region().start(); | |
266 break; | |
267 } | |
268 #endif // SERIALGC | |
269 default: | |
270 ShouldNotReachHere(); // Unexpected heap kind for this op | |
271 } | |
272 // Collect klass instance info | |
273 KlassInfoTable cit(KlassInfoTable::cit_size, ref); | |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
274 if (!cit.allocation_failed()) { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
275 // Iterate over objects in the heap |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
276 RecordInstanceClosure ric(&cit); |
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
356
diff
changeset
|
277 // If this operation encounters a bad object when using CMS, |
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
356
diff
changeset
|
278 // consider using safe_object_iterate() which avoids perm gen |
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
356
diff
changeset
|
279 // objects that may contain bad references. |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
280 Universe::heap()->object_iterate(&ric); |
0 | 281 |
11
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
282 // Report if certain classes are not counted because of |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
283 // running out of C-heap for the histogram. |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
284 size_t missed_count = ric.missed_count(); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
285 if (missed_count != 0) { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
286 st->print_cr("WARNING: Ran out of C-heap; undercounted " SIZE_FORMAT |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
287 " total instances in data below", |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
288 missed_count); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
289 } |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
290 // Sort and print klass instance info |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
291 KlassInfoHisto histo("\n" |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
292 " num #instances #bytes class name\n" |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
293 "----------------------------------------------", |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
294 KlassInfoHisto::histo_initial_size); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
295 HistoClosure hc(&histo); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
296 cit.iterate(&hc); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
297 histo.sort(); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
298 histo.print_on(st); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
299 } else { |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
300 st->print_cr("WARNING: Ran out of C-heap; histogram not generated"); |
3c1dbcaaab1d
6621728: Heap inspection should not crash in the face of C-heap exhaustion
ysr
parents:
0
diff
changeset
|
301 } |
0 | 302 st->flush(); |
303 | |
615
c6c601a0f2d6
6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC
ysr
parents:
517
diff
changeset
|
304 if (need_prologue && is_shared_heap) { |
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
11
diff
changeset
|
305 SharedHeap* sh = (SharedHeap*)heap; |
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
11
diff
changeset
|
306 sh->gc_epilogue(false /* !full */); // release all acquired locks, etc. |
0 | 307 } |
308 } | |
309 | |
310 class FindInstanceClosure : public ObjectClosure { | |
311 private: | |
312 klassOop _klass; | |
313 GrowableArray<oop>* _result; | |
314 | |
315 public: | |
316 FindInstanceClosure(klassOop k, GrowableArray<oop>* result) : _klass(k), _result(result) {}; | |
317 | |
318 void do_object(oop obj) { | |
319 if (obj->is_a(_klass)) { | |
320 _result->append(obj); | |
321 } | |
322 } | |
323 }; | |
324 | |
325 void HeapInspection::find_instances_at_safepoint(klassOop k, GrowableArray<oop>* result) { | |
326 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped"); | |
1489
cff162798819
6888953: some calls to function-like macros are missing semicolons
jcoomes
parents:
628
diff
changeset
|
327 assert(Heap_lock->is_locked(), "should have the Heap_lock"); |
0 | 328 |
329 // Ensure that the heap is parsable | |
330 Universe::heap()->ensure_parsability(false); // no need to retire TALBs | |
331 | |
332 // Iterate over objects in the heap | |
333 FindInstanceClosure fic(k, result); | |
517
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
356
diff
changeset
|
334 // If this operation encounters a bad object when using CMS, |
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
356
diff
changeset
|
335 // consider using safe_object_iterate() which avoids perm gen |
e9be0e04635a
6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off
jmasa
parents:
356
diff
changeset
|
336 // objects that may contain bad references. |
0 | 337 Universe::heap()->object_iterate(&fic); |
338 } |