size_t HeapInspection::populate_table(KlassInfoTable* cit, BoolObjectClosure *filter) {
ResourceMark rm;
RecordInstanceClosure ric(cit, filter);
Universe::heap()->object_iterate(&ric);
return ric.missed_count();
}
void HeapInspection::heap_inspection() {
ResourceMark rm;
HeapWord* permgen_bottom = NULL;
if (Universe::heap()->kind() == CollectedHeap::GenCollectedHeap) {
GenCollectedHeap* gch = GenCollectedHeap::heap();
gch->gc_prologue(false /* !full */); // get any necessary locks
permgen_bottom = gch->perm_gen()->used_region().start();
} else {
return;
}
// Collect klass instance info
// Iterate over objects in the heap
KlassInfoTable cit(KlassInfoTable::cit_size, permgen_bottom);
RecordInstanceClosure ric(&cit);
Universe::heap()->object_iterate(&ric);
// Sort and print klass instance info
KlassInfoHisto histo("\n"
"num #instances #bytes class name\n"
"--------------------------------------",
KlassInfoHisto::histo_initial_size);
HistoClosure hc(&histo);
cit.iterate(&hc);
histo.sort();
histo.print_on(gclog_or_tty);
gclog_or_tty->flush();
if (Universe::heap()->kind() == CollectedHeap::GenCollectedHeap) {
GenCollectedHeap* gch = GenCollectedHeap::heap();
gch->gc_epilogue(false /* !full */); // release all acquired locks
}
}
//----------------------------------------------------------------------------//
void BasicRenderedStringParser::handleImage(RenderedString& rs, const String& value)
{
RenderedStringImageComponent ric(
PropertyHelper<Image*>::fromString(value));
ric.setPadding(d_padding);
ric.setColours(d_colours);
ric.setVerticalFormatting(d_vertAlignment);
ric.setSize(d_imageSize);
ric.setAspectLock(d_aspectLock);
rs.appendComponent(ric);
}
size_t HeapInspection::populate_table(KlassInfoTable* cit,
bool need_prologue,
BoolObjectClosure *filter) {
ResourceMark rm;
if (need_prologue) {
prologue();
}
RecordInstanceClosure ric(cit, filter);
Universe::heap()->object_iterate(&ric);
// need to run epilogue if we run prologue
if (need_prologue) {
epilogue();
}
return ric.missed_count();
}
void HeapInspection::heap_inspection(outputStream* st, bool need_prologue) {
ResourceMark rm;
HeapWord* ref;
CollectedHeap* heap = Universe::heap();
bool is_shared_heap = false;
switch (heap->kind()) {
case CollectedHeap::G1CollectedHeap:
case CollectedHeap::GenCollectedHeap: {
is_shared_heap = true;
SharedHeap* sh = (SharedHeap*)heap;
if (need_prologue) {
sh->gc_prologue(false /* !full */); // get any necessary locks, etc.
}
ref = sh->perm_gen()->used_region().start();
break;
}
#ifndef SERIALGC
case CollectedHeap::ParallelScavengeHeap: {
ParallelScavengeHeap* psh = (ParallelScavengeHeap*)heap;
ref = psh->perm_gen()->object_space()->used_region().start();
break;
}
#endif // SERIALGC
default:
ShouldNotReachHere(); // Unexpected heap kind for this op
}
// Collect klass instance info
KlassInfoTable cit(KlassInfoTable::cit_size, ref);
if (!cit.allocation_failed()) {
// Iterate over objects in the heap
RecordInstanceClosure ric(&cit);
// If this operation encounters a bad object when using CMS,
// consider using safe_object_iterate() which avoids perm gen
// objects that may contain bad references.
Universe::heap()->object_iterate(&ric);
// Report if certain classes are not counted because of
// running out of C-heap for the histogram.
size_t missed_count = ric.missed_count();
if (missed_count != 0) {
st->print_cr("WARNING: Ran out of C-heap; undercounted " SIZE_FORMAT
" total instances in data below",
missed_count);
}
// Sort and print klass instance info
KlassInfoHisto histo("\n"
" num #instances #bytes class name\n"
"----------------------------------------------",
KlassInfoHisto::histo_initial_size);
HistoClosure hc(&histo);
cit.iterate(&hc);
histo.sort();
histo.print_on(st);
} else {
st->print_cr("WARNING: Ran out of C-heap; histogram not generated");
}
st->flush();
if (need_prologue && is_shared_heap) {
SharedHeap* sh = (SharedHeap*)heap;
sh->gc_epilogue(false /* !full */); // release all acquired locks, etc.
}
}
