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
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
2 * Copyright (c) 2002, 2010, 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: 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
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: 1552
diff changeset
25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
26 #include "gc_interface/collectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
27 #include "memory/genCollectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
28 #include "memory/heapInspection.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
29 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
30 #include "oops/klassOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
31 #include "runtime/os.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
32 #include "utilities/globalDefinitions.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
33 #ifndef SERIALGC
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
34 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1552
diff changeset
35 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
36
a61af66fc99e Initial load
duke
parents:
diff changeset
37 // HeapInspection
a61af66fc99e Initial load
duke
parents:
diff changeset
38
a61af66fc99e Initial load
duke
parents:
diff changeset
39 int KlassInfoEntry::compare(KlassInfoEntry* e1, KlassInfoEntry* e2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
40 if(e1->_instance_words > e2->_instance_words) {
a61af66fc99e Initial load
duke
parents:
diff changeset
41 return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
42 } else if(e1->_instance_words < e2->_instance_words) {
a61af66fc99e Initial load
duke
parents:
diff changeset
43 return 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
44 }
a61af66fc99e Initial load
duke
parents:
diff changeset
45 return 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
46 }
a61af66fc99e Initial load
duke
parents:
diff changeset
47
a61af66fc99e Initial load
duke
parents:
diff changeset
48 void KlassInfoEntry::print_on(outputStream* st) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
49 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
50 const char* name;;
a61af66fc99e Initial load
duke
parents:
diff changeset
51 if (_klass->klass_part()->name() != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
52 name = _klass->klass_part()->external_name();
a61af66fc99e Initial load
duke
parents:
diff changeset
53 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
54 if (_klass == Universe::klassKlassObj()) name = "<klassKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
55 if (_klass == Universe::arrayKlassKlassObj()) name = "<arrayKlassKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
56 if (_klass == Universe::objArrayKlassKlassObj()) name = "<objArrayKlassKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
57 if (_klass == Universe::instanceKlassKlassObj()) name = "<instanceKlassKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
58 if (_klass == Universe::typeArrayKlassKlassObj()) name = "<typeArrayKlassKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
59 if (_klass == Universe::symbolKlassObj()) name = "<symbolKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
60 if (_klass == Universe::boolArrayKlassObj()) name = "<boolArrayKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
61 if (_klass == Universe::charArrayKlassObj()) name = "<charArrayKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
62 if (_klass == Universe::singleArrayKlassObj()) name = "<singleArrayKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
63 if (_klass == Universe::doubleArrayKlassObj()) name = "<doubleArrayKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
64 if (_klass == Universe::byteArrayKlassObj()) name = "<byteArrayKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
65 if (_klass == Universe::shortArrayKlassObj()) name = "<shortArrayKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
66 if (_klass == Universe::intArrayKlassObj()) name = "<intArrayKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
67 if (_klass == Universe::longArrayKlassObj()) name = "<longArrayKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
68 if (_klass == Universe::methodKlassObj()) name = "<methodKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
69 if (_klass == Universe::constMethodKlassObj()) name = "<constMethodKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
70 if (_klass == Universe::methodDataKlassObj()) name = "<methodDataKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
71 if (_klass == Universe::constantPoolKlassObj()) name = "<constantPoolKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
72 if (_klass == Universe::constantPoolCacheKlassObj()) name = "<constantPoolCacheKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
73 if (_klass == Universe::compiledICHolderKlassObj()) name = "<compiledICHolderKlass>"; else
a61af66fc99e Initial load
duke
parents:
diff changeset
74 name = "<no name>";
a61af66fc99e Initial load
duke
parents:
diff changeset
75 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
78 (jlong) _instance_count,
a61af66fc99e Initial load
duke
parents:
diff changeset
79 (julong) _instance_words * HeapWordSize,
a61af66fc99e Initial load
duke
parents:
diff changeset
80 name);
a61af66fc99e Initial load
duke
parents:
diff changeset
81 }
a61af66fc99e Initial load
duke
parents:
diff changeset
82
a61af66fc99e Initial load
duke
parents:
diff changeset
83 KlassInfoEntry* KlassInfoBucket::lookup(const klassOop k) {
a61af66fc99e Initial load
duke
parents:
diff changeset
84 KlassInfoEntry* elt = _list;
a61af66fc99e Initial load
duke
parents:
diff changeset
85 while (elt != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
86 if (elt->is_equal(k)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
87 return elt;
a61af66fc99e Initial load
duke
parents:
diff changeset
88 }
a61af66fc99e Initial load
duke
parents:
diff changeset
89 elt = elt->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
90 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
96 return elt;
a61af66fc99e Initial load
duke
parents:
diff changeset
97 }
a61af66fc99e Initial load
duke
parents:
diff changeset
98
a61af66fc99e Initial load
duke
parents:
diff changeset
99 void KlassInfoBucket::iterate(KlassInfoClosure* cic) {
a61af66fc99e Initial load
duke
parents:
diff changeset
100 KlassInfoEntry* elt = _list;
a61af66fc99e Initial load
duke
parents:
diff changeset
101 while (elt != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
102 cic->do_cinfo(elt);
a61af66fc99e Initial load
duke
parents:
diff changeset
103 elt = elt->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
104 }
a61af66fc99e Initial load
duke
parents:
diff changeset
105 }
a61af66fc99e Initial load
duke
parents:
diff changeset
106
a61af66fc99e Initial load
duke
parents:
diff changeset
107 void KlassInfoBucket::empty() {
a61af66fc99e Initial load
duke
parents:
diff changeset
108 KlassInfoEntry* elt = _list;
a61af66fc99e Initial load
duke
parents:
diff changeset
109 _list = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
110 while (elt != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
111 KlassInfoEntry* next = elt->next();
a61af66fc99e Initial load
duke
parents:
diff changeset
112 delete elt;
a61af66fc99e Initial load
duke
parents:
diff changeset
113 elt = next;
a61af66fc99e Initial load
duke
parents:
diff changeset
114 }
a61af66fc99e Initial load
duke
parents:
diff changeset
115 }
a61af66fc99e Initial load
duke
parents:
diff changeset
116
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
126 }
a61af66fc99e Initial load
duke
parents:
diff changeset
127 }
a61af66fc99e Initial load
duke
parents:
diff changeset
128
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
136 }
a61af66fc99e Initial load
duke
parents:
diff changeset
137 }
a61af66fc99e Initial load
duke
parents:
diff changeset
138
a61af66fc99e Initial load
duke
parents:
diff changeset
139 uint KlassInfoTable::hash(klassOop p) {
a61af66fc99e Initial load
duke
parents:
diff changeset
140 assert(Universe::heap()->is_in_permanent((HeapWord*)p), "all klasses in permgen");
a61af66fc99e Initial load
duke
parents:
diff changeset
141 return (uint)(((uintptr_t)p - (uintptr_t)_ref) >> 2);
a61af66fc99e Initial load
duke
parents:
diff changeset
142 }
a61af66fc99e Initial load
duke
parents:
diff changeset
143
a61af66fc99e Initial load
duke
parents:
diff changeset
144 KlassInfoEntry* KlassInfoTable::lookup(const klassOop k) {
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
151 return e;
a61af66fc99e Initial load
duke
parents:
diff changeset
152 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
157 klassOop k = obj->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
168 }
a61af66fc99e Initial load
duke
parents:
diff changeset
169
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
172 for (int index = 0; index < _size; index++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
173 _buckets[index].iterate(cic);
a61af66fc99e Initial load
duke
parents:
diff changeset
174 }
a61af66fc99e Initial load
duke
parents:
diff changeset
175 }
a61af66fc99e Initial load
duke
parents:
diff changeset
176
a61af66fc99e Initial load
duke
parents:
diff changeset
177 int KlassInfoHisto::sort_helper(KlassInfoEntry** e1, KlassInfoEntry** e2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
178 return (*e1)->compare(*e1,*e2);
a61af66fc99e Initial load
duke
parents:
diff changeset
179 }
a61af66fc99e Initial load
duke
parents:
diff changeset
180
a61af66fc99e Initial load
duke
parents:
diff changeset
181 KlassInfoHisto::KlassInfoHisto(const char* title, int estimatedCount) :
a61af66fc99e Initial load
duke
parents:
diff changeset
182 _title(title) {
a61af66fc99e Initial load
duke
parents:
diff changeset
183 _elements = new (ResourceObj::C_HEAP) GrowableArray<KlassInfoEntry*>(estimatedCount,true);
a61af66fc99e Initial load
duke
parents:
diff changeset
184 }
a61af66fc99e Initial load
duke
parents:
diff changeset
185
a61af66fc99e Initial load
duke
parents:
diff changeset
186 KlassInfoHisto::~KlassInfoHisto() {
a61af66fc99e Initial load
duke
parents:
diff changeset
187 delete _elements;
a61af66fc99e Initial load
duke
parents:
diff changeset
188 }
a61af66fc99e Initial load
duke
parents:
diff changeset
189
a61af66fc99e Initial load
duke
parents:
diff changeset
190 void KlassInfoHisto::add(KlassInfoEntry* cie) {
a61af66fc99e Initial load
duke
parents:
diff changeset
191 elements()->append(cie);
a61af66fc99e Initial load
duke
parents:
diff changeset
192 }
a61af66fc99e Initial load
duke
parents:
diff changeset
193
a61af66fc99e Initial load
duke
parents:
diff changeset
194 void KlassInfoHisto::sort() {
a61af66fc99e Initial load
duke
parents:
diff changeset
195 elements()->sort(KlassInfoHisto::sort_helper);
a61af66fc99e Initial load
duke
parents:
diff changeset
196 }
a61af66fc99e Initial load
duke
parents:
diff changeset
197
a61af66fc99e Initial load
duke
parents:
diff changeset
198 void KlassInfoHisto::print_elements(outputStream* st) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
199 // simplify the formatting (ILP32 vs LP64) - store the sum in 64-bit
a61af66fc99e Initial load
duke
parents:
diff changeset
200 jlong total = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
201 julong totalw = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
202 for(int i=0; i < elements()->length(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
203 st->print("%4d: ", i+1);
a61af66fc99e Initial load
duke
parents:
diff changeset
204 elements()->at(i)->print_on(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
205 total += elements()->at(i)->count();
a61af66fc99e Initial load
duke
parents:
diff changeset
206 totalw += elements()->at(i)->words();
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
209 total, totalw * HeapWordSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
210 }
a61af66fc99e Initial load
duke
parents:
diff changeset
211
a61af66fc99e Initial load
duke
parents:
diff changeset
212 void KlassInfoHisto::print_on(outputStream* st) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
213 st->print_cr("%s",title());
a61af66fc99e Initial load
duke
parents:
diff changeset
214 print_elements(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
215 }
a61af66fc99e Initial load
duke
parents:
diff changeset
216
a61af66fc99e Initial load
duke
parents:
diff changeset
217 class HistoClosure : public KlassInfoClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
218 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
219 KlassInfoHisto* _cih;
a61af66fc99e Initial load
duke
parents:
diff changeset
220 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
221 HistoClosure(KlassInfoHisto* cih) : _cih(cih) {}
a61af66fc99e Initial load
duke
parents:
diff changeset
222
a61af66fc99e Initial load
duke
parents:
diff changeset
223 void do_cinfo(KlassInfoEntry* cie) {
a61af66fc99e Initial load
duke
parents:
diff changeset
224 _cih->add(cie);
a61af66fc99e Initial load
duke
parents:
diff changeset
225 }
a61af66fc99e Initial load
duke
parents:
diff changeset
226 };
a61af66fc99e Initial load
duke
parents:
diff changeset
227
a61af66fc99e Initial load
duke
parents:
diff changeset
228 class RecordInstanceClosure : public ObjectClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
229 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
235
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
243 };
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
246 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
247 HeapWord* ref;
a61af66fc99e Initial load
duke
parents:
diff changeset
248
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
251 switch (heap->kind()) {
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 11
diff changeset
252 case CollectedHeap::G1CollectedHeap:
0
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
260 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
261 }
a61af66fc99e Initial load
duke
parents:
diff changeset
262 #ifndef SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
263 case CollectedHeap::ParallelScavengeHeap: {
a61af66fc99e Initial load
duke
parents:
diff changeset
264 ParallelScavengeHeap* psh = (ParallelScavengeHeap*)heap;
a61af66fc99e Initial load
duke
parents:
diff changeset
265 ref = psh->perm_gen()->object_space()->used_region().start();
a61af66fc99e Initial load
duke
parents:
diff changeset
266 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
267 }
a61af66fc99e Initial load
duke
parents:
diff changeset
268 #endif // SERIALGC
a61af66fc99e Initial load
duke
parents:
diff changeset
269 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
270 ShouldNotReachHere(); // Unexpected heap kind for this op
a61af66fc99e Initial load
duke
parents:
diff changeset
271 }
a61af66fc99e Initial load
duke
parents:
diff changeset
272 // Collect klass instance info
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
302 st->flush();
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
307 }
a61af66fc99e Initial load
duke
parents:
diff changeset
308 }
a61af66fc99e Initial load
duke
parents:
diff changeset
309
a61af66fc99e Initial load
duke
parents:
diff changeset
310 class FindInstanceClosure : public ObjectClosure {
a61af66fc99e Initial load
duke
parents:
diff changeset
311 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
312 klassOop _klass;
a61af66fc99e Initial load
duke
parents:
diff changeset
313 GrowableArray<oop>* _result;
a61af66fc99e Initial load
duke
parents:
diff changeset
314
a61af66fc99e Initial load
duke
parents:
diff changeset
315 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
316 FindInstanceClosure(klassOop k, GrowableArray<oop>* result) : _klass(k), _result(result) {};
a61af66fc99e Initial load
duke
parents:
diff changeset
317
a61af66fc99e Initial load
duke
parents:
diff changeset
318 void do_object(oop obj) {
a61af66fc99e Initial load
duke
parents:
diff changeset
319 if (obj->is_a(_klass)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
320 _result->append(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
321 }
a61af66fc99e Initial load
duke
parents:
diff changeset
322 }
a61af66fc99e Initial load
duke
parents:
diff changeset
323 };
a61af66fc99e Initial load
duke
parents:
diff changeset
324
a61af66fc99e Initial load
duke
parents:
diff changeset
325 void HeapInspection::find_instances_at_safepoint(klassOop k, GrowableArray<oop>* result) {
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
328
a61af66fc99e Initial load
duke
parents:
diff changeset
329 // Ensure that the heap is parsable
a61af66fc99e Initial load
duke
parents:
diff changeset
330 Universe::heap()->ensure_parsability(false); // no need to retire TALBs
a61af66fc99e Initial load
duke
parents:
diff changeset
331
a61af66fc99e Initial load
duke
parents:
diff changeset
332 // Iterate over objects in the heap
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
337 Universe::heap()->object_iterate(&fic);
a61af66fc99e Initial load
duke
parents:
diff changeset
338 }