truffle: src/share/vm/memory/heapInspection.cpp annotate

annotate src/share/vm/memory/heapInspection.cpp @ 8001:db9981fd3124

8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS Summary: Rename INCLUDE_ALTERNATE_GCS to INCLUDE_ALL_GCS and replace SERIALGC with INCLUDE_ALL_GCS. Reviewed-by: coleenp, stefank

author	jprovino
date	Wed, 23 Jan 2013 13:02:39 -0500
parents	da91efe96a93
children	3c9bc17b9403

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	2 * Copyright (c) 2002, 2012, 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 "runtime/os.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	31 #include "utilities/globalDefinitions.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	32 #include "utilities/macros.hpp"
db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	33 #if INCLUDE_ALL_GCS
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6725 diff changeset	35 #endif // INCLUDE_ALL_GCS
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;;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	51 if (_klass->name() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	52 name = _klass->external_name();
0 a61af66fc99e Initial load duke parents: diff changeset	53 } else {
a61af66fc99e Initial load duke parents: diff changeset	54 if (_klass == Universe::boolArrayKlassObj()) name = "<boolArrayKlass>"; else
a61af66fc99e Initial load duke parents: diff changeset	55 if (_klass == Universe::charArrayKlassObj()) name = "<charArrayKlass>"; else
a61af66fc99e Initial load duke parents: diff changeset	56 if (_klass == Universe::singleArrayKlassObj()) name = "<singleArrayKlass>"; else
a61af66fc99e Initial load duke parents: diff changeset	57 if (_klass == Universe::doubleArrayKlassObj()) name = "<doubleArrayKlass>"; else
a61af66fc99e Initial load duke parents: diff changeset	58 if (_klass == Universe::byteArrayKlassObj()) name = "<byteArrayKlass>"; else
a61af66fc99e Initial load duke parents: diff changeset	59 if (_klass == Universe::shortArrayKlassObj()) name = "<shortArrayKlass>"; else
a61af66fc99e Initial load duke parents: diff changeset	60 if (_klass == Universe::intArrayKlassObj()) name = "<intArrayKlass>"; else
a61af66fc99e Initial load duke parents: diff changeset	61 if (_klass == Universe::longArrayKlassObj()) name = "<longArrayKlass>"; else
a61af66fc99e Initial load duke parents: diff changeset	62 name = "<no name>";
a61af66fc99e Initial load duke parents: diff changeset	63 }
a61af66fc99e Initial load duke parents: diff changeset	64 // 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	65 st->print_cr(INT64_FORMAT_W(13) " " UINT64_FORMAT_W(13) " %s",
0 a61af66fc99e Initial load duke parents: diff changeset	66 (jlong) _instance_count,
a61af66fc99e Initial load duke parents: diff changeset	67 (julong) _instance_words * HeapWordSize,
a61af66fc99e Initial load duke parents: diff changeset	68 name);
a61af66fc99e Initial load duke parents: diff changeset	69 }
a61af66fc99e Initial load duke parents: diff changeset	70
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	71 KlassInfoEntry* KlassInfoBucket::lookup(Klass* const k) {
0 a61af66fc99e Initial load duke parents: diff changeset	72 KlassInfoEntry* elt = _list;
a61af66fc99e Initial load duke parents: diff changeset	73 while (elt != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	74 if (elt->is_equal(k)) {
a61af66fc99e Initial load duke parents: diff changeset	75 return elt;
a61af66fc99e Initial load duke parents: diff changeset	76 }
a61af66fc99e Initial load duke parents: diff changeset	77 elt = elt->next();
a61af66fc99e Initial load duke parents: diff changeset	78 }
a61af66fc99e Initial load duke parents: diff changeset	79 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	80 // 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	81 if (elt != NULL) {
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	82 set_list(elt);
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	83 }
0 a61af66fc99e Initial load duke parents: diff changeset	84 return elt;
a61af66fc99e Initial load duke parents: diff changeset	85 }
a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87 void KlassInfoBucket::iterate(KlassInfoClosure* cic) {
a61af66fc99e Initial load duke parents: diff changeset	88 KlassInfoEntry* elt = _list;
a61af66fc99e Initial load duke parents: diff changeset	89 while (elt != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	90 cic->do_cinfo(elt);
a61af66fc99e Initial load duke parents: diff changeset	91 elt = elt->next();
a61af66fc99e Initial load duke parents: diff changeset	92 }
a61af66fc99e Initial load duke parents: diff changeset	93 }
a61af66fc99e Initial load duke parents: diff changeset	94
a61af66fc99e Initial load duke parents: diff changeset	95 void KlassInfoBucket::empty() {
a61af66fc99e Initial load duke parents: diff changeset	96 KlassInfoEntry* elt = _list;
a61af66fc99e Initial load duke parents: diff changeset	97 _list = NULL;
a61af66fc99e Initial load duke parents: diff changeset	98 while (elt != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	99 KlassInfoEntry* next = elt->next();
a61af66fc99e Initial load duke parents: diff changeset	100 delete elt;
a61af66fc99e Initial load duke parents: diff changeset	101 elt = next;
a61af66fc99e Initial load duke parents: diff changeset	102 }
a61af66fc99e Initial load duke parents: diff changeset	103 }
a61af66fc99e Initial load duke parents: diff changeset	104
a61af66fc99e Initial load duke parents: diff changeset	105 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	106 _size = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	107 _ref = ref;
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2426 diff changeset	108 _buckets = NEW_C_HEAP_ARRAY(KlassInfoBucket, size, mtInternal);
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	109 if (_buckets != NULL) {
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	110 _size = size;
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	111 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	112 _buckets[index].initialize();
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	113 }
0 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() {
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	118 if (_buckets != NULL) {
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	119 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	120 _buckets[index].empty();
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	121 }
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2426 diff changeset	122 FREE_C_HEAP_ARRAY(KlassInfoBucket, _buckets, mtInternal);
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	123 _size = 0;
0 a61af66fc99e Initial load duke parents: diff changeset	124 }
a61af66fc99e Initial load duke parents: diff changeset	125 }
a61af66fc99e Initial load duke parents: diff changeset	126
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	127 uint KlassInfoTable::hash(Klass* p) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	128 assert(p->is_metadata(), "all klasses are metadata");
0 a61af66fc99e Initial load duke parents: diff changeset	129 return (uint)(((uintptr_t)p - (uintptr_t)_ref) >> 2);
a61af66fc99e Initial load duke parents: diff changeset	130 }
a61af66fc99e Initial load duke parents: diff changeset	131
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	132 KlassInfoEntry* KlassInfoTable::lookup(Klass* const k) {
0 a61af66fc99e Initial load duke parents: diff changeset	133 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	134 assert(_buckets != NULL, "Allocation failure should have been caught");
0 a61af66fc99e Initial load duke parents: diff changeset	135 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	136 // 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	137 // 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	138 assert(e == NULL \|\| k == e->klass(), "must be equal");
0 a61af66fc99e Initial load duke parents: diff changeset	139 return e;
a61af66fc99e Initial load duke parents: diff changeset	140 }
a61af66fc99e Initial load duke parents: diff changeset	141
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	142 // 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	143 // 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	144 bool KlassInfoTable::record_instance(const oop obj) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	145 Klass* k = obj->klass();
0 a61af66fc99e Initial load duke parents: diff changeset	146 KlassInfoEntry* elt = lookup(k);
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	147 // 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	148 // 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	149 if (elt != NULL) {
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	150 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	151 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	152 return true;
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	153 } else {
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	154 return false;
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	155 }
0 a61af66fc99e Initial load duke parents: diff changeset	156 }
a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 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	159 assert(_size == 0 \|\| _buckets != NULL, "Allocation failure should have been caught");
0 a61af66fc99e Initial load duke parents: diff changeset	160 for (int index = 0; index < _size; index++) {
a61af66fc99e Initial load duke parents: diff changeset	161 _buckets[index].iterate(cic);
a61af66fc99e Initial load duke parents: diff changeset	162 }
a61af66fc99e Initial load duke parents: diff changeset	163 }
a61af66fc99e Initial load duke parents: diff changeset	164
a61af66fc99e Initial load duke parents: diff changeset	165 int KlassInfoHisto::sort_helper(KlassInfoEntry e1, KlassInfoEntry e2) {
a61af66fc99e Initial load duke parents: diff changeset	166 return (e1)->compare(e1,*e2);
a61af66fc99e Initial load duke parents: diff changeset	167 }
a61af66fc99e Initial load duke parents: diff changeset	168
a61af66fc99e Initial load duke parents: diff changeset	169 KlassInfoHisto::KlassInfoHisto(const char* title, int estimatedCount) :
a61af66fc99e Initial load duke parents: diff changeset	170 _title(title) {
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 2426 diff changeset	171 _elements = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<KlassInfoEntry*>(estimatedCount,true);
0 a61af66fc99e Initial load duke parents: diff changeset	172 }
a61af66fc99e Initial load duke parents: diff changeset	173
a61af66fc99e Initial load duke parents: diff changeset	174 KlassInfoHisto::~KlassInfoHisto() {
a61af66fc99e Initial load duke parents: diff changeset	175 delete _elements;
a61af66fc99e Initial load duke parents: diff changeset	176 }
a61af66fc99e Initial load duke parents: diff changeset	177
a61af66fc99e Initial load duke parents: diff changeset	178 void KlassInfoHisto::add(KlassInfoEntry* cie) {
a61af66fc99e Initial load duke parents: diff changeset	179 elements()->append(cie);
a61af66fc99e Initial load duke parents: diff changeset	180 }
a61af66fc99e Initial load duke parents: diff changeset	181
a61af66fc99e Initial load duke parents: diff changeset	182 void KlassInfoHisto::sort() {
a61af66fc99e Initial load duke parents: diff changeset	183 elements()->sort(KlassInfoHisto::sort_helper);
a61af66fc99e Initial load duke parents: diff changeset	184 }
a61af66fc99e Initial load duke parents: diff changeset	185
a61af66fc99e Initial load duke parents: diff changeset	186 void KlassInfoHisto::print_elements(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	187 // simplify the formatting (ILP32 vs LP64) - store the sum in 64-bit
a61af66fc99e Initial load duke parents: diff changeset	188 jlong total = 0;
a61af66fc99e Initial load duke parents: diff changeset	189 julong totalw = 0;
a61af66fc99e Initial load duke parents: diff changeset	190 for(int i=0; i < elements()->length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	191 st->print("%4d: ", i+1);
a61af66fc99e Initial load duke parents: diff changeset	192 elements()->at(i)->print_on(st);
a61af66fc99e Initial load duke parents: diff changeset	193 total += elements()->at(i)->count();
a61af66fc99e Initial load duke parents: diff changeset	194 totalw += elements()->at(i)->words();
a61af66fc99e Initial load duke parents: diff changeset	195 }
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	196 st->print_cr("Total " INT64_FORMAT_W(13) " " UINT64_FORMAT_W(13),
0 a61af66fc99e Initial load duke parents: diff changeset	197 total, totalw * HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	198 }
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 void KlassInfoHisto::print_on(outputStream* st) const {
a61af66fc99e Initial load duke parents: diff changeset	201 st->print_cr("%s",title());
a61af66fc99e Initial load duke parents: diff changeset	202 print_elements(st);
a61af66fc99e Initial load duke parents: diff changeset	203 }
a61af66fc99e Initial load duke parents: diff changeset	204
a61af66fc99e Initial load duke parents: diff changeset	205 class HistoClosure : public KlassInfoClosure {
a61af66fc99e Initial load duke parents: diff changeset	206 private:
a61af66fc99e Initial load duke parents: diff changeset	207 KlassInfoHisto* _cih;
a61af66fc99e Initial load duke parents: diff changeset	208 public:
a61af66fc99e Initial load duke parents: diff changeset	209 HistoClosure(KlassInfoHisto* cih) : _cih(cih) {}
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 void do_cinfo(KlassInfoEntry* cie) {
a61af66fc99e Initial load duke parents: diff changeset	212 _cih->add(cie);
a61af66fc99e Initial load duke parents: diff changeset	213 }
a61af66fc99e Initial load duke parents: diff changeset	214 };
a61af66fc99e Initial load duke parents: diff changeset	215
a61af66fc99e Initial load duke parents: diff changeset	216 class RecordInstanceClosure : public ObjectClosure {
a61af66fc99e Initial load duke parents: diff changeset	217 private:
a61af66fc99e Initial load duke parents: diff changeset	218 KlassInfoTable* _cit;
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	219 size_t _missed_count;
0 a61af66fc99e Initial load duke parents: diff changeset	220 public:
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	221 RecordInstanceClosure(KlassInfoTable* cit) :
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	222 _cit(cit), _missed_count(0) {}
0 a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 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	225 if (!_cit->record_instance(obj)) {
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	226 _missed_count++;
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	227 }
0 a61af66fc99e Initial load duke parents: diff changeset	228 }
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	229
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	230 size_t missed_count() { return _missed_count; }
0 a61af66fc99e Initial load duke parents: diff changeset	231 };
a61af66fc99e Initial load duke parents: diff changeset	232
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 517 diff changeset	233 void HeapInspection::heap_inspection(outputStream* st, bool need_prologue) {
0 a61af66fc99e Initial load duke parents: diff changeset	234 ResourceMark rm;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	235 // Get some random number for ref (the hash key)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	236 HeapWord* ref = (HeapWord*) Universe::boolArrayKlassObj();
0 a61af66fc99e Initial load duke parents: diff changeset	237 CollectedHeap* heap = Universe::heap();
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 11 diff changeset	238 bool is_shared_heap = false;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	239
0 a61af66fc99e Initial load duke parents: diff changeset	240 // Collect klass instance info
a61af66fc99e Initial load duke parents: diff changeset	241 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	242 if (!cit.allocation_failed()) {
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	243 // 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	244 RecordInstanceClosure ric(&cit);
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	245 Universe::heap()->object_iterate(&ric);
0 a61af66fc99e Initial load duke parents: diff changeset	246
11 3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	247 // 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	248 // 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	249 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	250 if (missed_count != 0) {
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	251 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	252 " total instances in data below",
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	253 missed_count);
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	254 }
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	255 // 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	256 KlassInfoHisto histo("\n"
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	257 " 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	258 "----------------------------------------------",
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	259 KlassInfoHisto::histo_initial_size);
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	260 HistoClosure hc(&histo);
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	261 cit.iterate(&hc);
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	262 histo.sort();
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	263 histo.print_on(st);
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	264 } else {
3c1dbcaaab1d 6621728: Heap inspection should not crash in the face of C-heap exhaustion ysr parents: 0 diff changeset	265 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	266 }
0 a61af66fc99e Initial load duke parents: diff changeset	267 st->flush();
a61af66fc99e Initial load duke parents: diff changeset	268
615 c6c601a0f2d6 6797870: Add -XX:+{HeapDump,PrintClassHistogram}{Before,After}FullGC ysr parents: 517 diff changeset	269 if (need_prologue && is_shared_heap) {
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 11 diff changeset	270 SharedHeap* sh = (SharedHeap*)heap;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 11 diff changeset	271 sh->gc_epilogue(false /* !full */); // release all acquired locks, etc.
0 a61af66fc99e Initial load duke parents: diff changeset	272 }
a61af66fc99e Initial load duke parents: diff changeset	273 }
a61af66fc99e Initial load duke parents: diff changeset	274
a61af66fc99e Initial load duke parents: diff changeset	275 class FindInstanceClosure : public ObjectClosure {
a61af66fc99e Initial load duke parents: diff changeset	276 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	277 Klass* _klass;
0 a61af66fc99e Initial load duke parents: diff changeset	278 GrowableArray<oop>* _result;
a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	281 FindInstanceClosure(Klass* k, GrowableArray<oop>* result) : _klass(k), _result(result) {};
0 a61af66fc99e Initial load duke parents: diff changeset	282
a61af66fc99e Initial load duke parents: diff changeset	283 void do_object(oop obj) {
a61af66fc99e Initial load duke parents: diff changeset	284 if (obj->is_a(_klass)) {
a61af66fc99e Initial load duke parents: diff changeset	285 _result->append(obj);
a61af66fc99e Initial load duke parents: diff changeset	286 }
a61af66fc99e Initial load duke parents: diff changeset	287 }
a61af66fc99e Initial load duke parents: diff changeset	288 };
a61af66fc99e Initial load duke parents: diff changeset	289
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	290 void HeapInspection::find_instances_at_safepoint(Klass* k, GrowableArray<oop>* result) {
0 a61af66fc99e Initial load duke parents: diff changeset	291 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	292 assert(Heap_lock->is_locked(), "should have the Heap_lock");
0 a61af66fc99e Initial load duke parents: diff changeset	293
a61af66fc99e Initial load duke parents: diff changeset	294 // Ensure that the heap is parsable
a61af66fc99e Initial load duke parents: diff changeset	295 Universe::heap()->ensure_parsability(false); // no need to retire TALBs
a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297 // Iterate over objects in the heap
a61af66fc99e Initial load duke parents: diff changeset	298 FindInstanceClosure fic(k, result);
517 e9be0e04635a 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off jmasa parents: 356 diff changeset	299 // If this operation encounters a bad object when using CMS,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	300 // consider using safe_object_iterate() which avoids metadata
517 e9be0e04635a 6689653: JMapPerm fails with UseConcMarkSweepIncGC and compressed oops off jmasa parents: 356 diff changeset	301 // objects that may contain bad references.
0 a61af66fc99e Initial load duke parents: diff changeset	302 Universe::heap()->object_iterate(&fic);
a61af66fc99e Initial load duke parents: diff changeset	303 }

Mercurial > hg > truffle

annotate src/share/vm/memory/heapInspection.cpp @ 8001:db9981fd3124