archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-21 03:24:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

6964458: Reimplement class meta-data storage to use native memory

Browse source 
Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes

Co-authored-by: Stefan Karlsson <stefan.karlsson@oracle.com>
Co-authored-by: Mikael Gerdin <mikael.gerdin@oracle.com>
Co-authored-by: Tom Rodriguez <tom.rodriguez@oracle.com>
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
This commit is contained in:
Jon Masamitsu 2012-09-01 13:25:18 -04:00 • committed by Coleen Phillimore
parent 36eee7c8c8
commit 5c58d27aac
853 changed files with 26124 additions and 82956 deletions
Download patch file Download diff file Expand all files Collapse all files

231
hotspot/src/share/vm/memory/genCollectedHeap.cpp
View file

@ -30,14 +30,12 @@
#include "gc_implementation/shared/collectorCounters.hpp"
#include "gc_implementation/shared/vmGCOperations.hpp"
#include "gc_interface/collectedHeap.inline.hpp"
#include "memory/compactPermGen.hpp"
#include "memory/filemap.hpp"
#include "memory/gcLocker.inline.hpp"
#include "memory/genCollectedHeap.hpp"
#include "memory/genOopClosures.inline.hpp"
#include "memory/generation.inline.hpp"
#include "memory/generationSpec.hpp"
#include "memory/permGen.hpp"
#include "memory/resourceArea.hpp"
#include "memory/sharedHeap.hpp"
#include "memory/space.hpp"
@ -80,7 +78,6 @@ GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) :
vm_exit_during_initialization("Failed necessary allocation.");
}
assert(policy != NULL, "Sanity check");
_preloading_shared_classes = false;
}
jint GenCollectedHeap::initialize() {
@ -100,28 +97,11 @@ jint GenCollectedHeap::initialize() {
size_t alignment = Generation::GenGrain;
_gen_specs = gen_policy()->generations();
PermanentGenerationSpec *perm_gen_spec =
collector_policy()->permanent_generation();
// Make sure the sizes are all aligned.
for (i = 0; i < _n_gens; i++) {
_gen_specs[i]->align(alignment);
}
perm_gen_spec->align(alignment);
// If we are dumping the heap, then allocate a wasted block of address
// space in order to push the heap to a lower address. This extra
// address range allows for other (or larger) libraries to be loaded
// without them occupying the space required for the shared spaces.
if (DumpSharedSpaces) {
uintx reserved = 0;
uintx block_size = 64*1024*1024;
while (reserved < SharedDummyBlockSize) {
char* dummy = os::reserve_memory(block_size);
reserved += block_size;
}
}
// Allocate space for the heap.
@ -130,21 +110,9 @@ jint GenCollectedHeap::initialize() {
int n_covered_regions = 0;
ReservedSpace heap_rs(0);
heap_address = allocate(alignment, perm_gen_spec, &total_reserved,
heap_address = allocate(alignment, &total_reserved,
&n_covered_regions, &heap_rs);
if (UseSharedSpaces) {
if (!heap_rs.is_reserved() || heap_address != heap_rs.base()) {
if (heap_rs.is_reserved()) {
heap_rs.release();
}
FileMapInfo* mapinfo = FileMapInfo::current_info();
mapinfo->fail_continue("Unable to reserve shared region.");
allocate(alignment, perm_gen_spec, &total_reserved, &n_covered_regions,
&heap_rs);
}
}
if (!heap_rs.is_reserved()) {
vm_shutdown_during_initialization(
"Could not reserve enough space for object heap");
@ -158,8 +126,7 @@ jint GenCollectedHeap::initialize() {
// temporarily think somethings in the heap. (Seen this happen in asserts.)
_reserved.set_word_size(0);
_reserved.set_start((HeapWord*)heap_rs.base());
size_t actual_heap_size = heap_rs.size() - perm_gen_spec->misc_data_size()
- perm_gen_spec->misc_code_size();
size_t actual_heap_size = heap_rs.size();
_reserved.set_end((HeapWord*)(heap_rs.base() + actual_heap_size));
_rem_set = collector_policy()->create_rem_set(_reserved, n_covered_regions);
@ -168,13 +135,10 @@ jint GenCollectedHeap::initialize() {
_gch = this;
for (i = 0; i < _n_gens; i++) {
ReservedSpace this_rs = heap_rs.first_part(_gen_specs[i]->max_size(),
UseSharedSpaces, UseSharedSpaces);
ReservedSpace this_rs = heap_rs.first_part(_gen_specs[i]->max_size(), false, false);
_gens[i] = _gen_specs[i]->init(this_rs, i, rem_set());
heap_rs = heap_rs.last_part(_gen_specs[i]->max_size());
}
_perm_gen = perm_gen_spec->init(heap_rs, PermSize, rem_set());
clear_incremental_collection_failed();
#ifndef SERIALGC
@ -191,7 +155,6 @@ jint GenCollectedHeap::initialize() {
char* GenCollectedHeap::allocate(size_t alignment,
PermanentGenerationSpec* perm_gen_spec,
size_t* _total_reserved,
int* _n_covered_regions,
ReservedSpace* heap_rs){
@ -214,25 +177,10 @@ char* GenCollectedHeap::allocate(size_t alignment,
assert(total_reserved % pageSize == 0,
err_msg("Gen size; total_reserved=" SIZE_FORMAT ", pageSize="
SIZE_FORMAT, total_reserved, pageSize));
total_reserved += perm_gen_spec->max_size();
assert(total_reserved % pageSize == 0,
err_msg("Perm size; total_reserved=" SIZE_FORMAT ", pageSize="
SIZE_FORMAT ", perm gen max=" SIZE_FORMAT, total_reserved,
pageSize, perm_gen_spec->max_size()));
if (total_reserved < perm_gen_spec->max_size()) {
vm_exit_during_initialization(overflow_msg);
}
n_covered_regions += perm_gen_spec->n_covered_regions();
// Add the size of the data area which shares the same reserved area
// as the heap, but which is not actually part of the heap.
size_t s = perm_gen_spec->misc_data_size() + perm_gen_spec->misc_code_size();
total_reserved += s;
if (total_reserved < s) {
vm_exit_during_initialization(overflow_msg);
}
// Needed until the cardtable is fixed to have the right number
// of covered regions.
n_covered_regions += 2;
if (UseLargePages) {
assert(total_reserved != 0, "total_reserved cannot be 0");
@ -242,55 +190,10 @@ char* GenCollectedHeap::allocate(size_t alignment,
}
}
// Calculate the address at which the heap must reside in order for
// the shared data to be at the required address.
char* heap_address;
if (UseSharedSpaces) {
// Calculate the address of the first word beyond the heap.
FileMapInfo* mapinfo = FileMapInfo::current_info();
int lr = CompactingPermGenGen::n_regions - 1;
size_t capacity = align_size_up(mapinfo->space_capacity(lr), alignment);
heap_address = mapinfo->region_base(lr) + capacity;
// Calculate the address of the first word of the heap.
heap_address -= total_reserved;
} else {
heap_address = NULL; // any address will do.
if (UseCompressedOops) {
heap_address = Universe::preferred_heap_base(total_reserved, Universe::UnscaledNarrowOop);
*_total_reserved = total_reserved;
*_n_covered_regions = n_covered_regions;
*heap_rs = ReservedHeapSpace(total_reserved, alignment,
UseLargePages, heap_address);
if (heap_address != NULL && !heap_rs->is_reserved()) {
// Failed to reserve at specified address - the requested memory
// region is taken already, for example, by 'java' launcher.
// Try again to reserver heap higher.
heap_address = Universe::preferred_heap_base(total_reserved, Universe::ZeroBasedNarrowOop);
*heap_rs = ReservedHeapSpace(total_reserved, alignment,
UseLargePages, heap_address);
if (heap_address != NULL && !heap_rs->is_reserved()) {
// Failed to reserve at specified address again - give up.
heap_address = Universe::preferred_heap_base(total_reserved, Universe::HeapBasedNarrowOop);
assert(heap_address == NULL, "");
*heap_rs = ReservedHeapSpace(total_reserved, alignment,
UseLargePages, heap_address);
}
}
return heap_address;
}
}
*_total_reserved = total_reserved;
*_n_covered_regions = n_covered_regions;
*heap_rs = ReservedHeapSpace(total_reserved, alignment,
UseLargePages, heap_address);
return heap_address;
*heap_rs = Universe::reserve_heap(total_reserved, alignment);
return heap_rs->base();
}
@ -340,16 +243,12 @@ size_t GenCollectedHeap::used() const {
return res;
}
// Save the "used_region" for generations level and lower,
// and, if perm is true, for perm gen.
void GenCollectedHeap::save_used_regions(int level, bool perm) {
// Save the "used_region" for generations level and lower.
void GenCollectedHeap::save_used_regions(int level) {
assert(level < _n_gens, "Illegal level parameter");
for (int i = level; i >= 0; i--) {
_gens[i]->save_used_region();
}
if (perm) {
perm_gen()->save_used_region();
}
}
size_t GenCollectedHeap::max_capacity() const {
@ -477,7 +376,7 @@ void GenCollectedHeap::do_collection(bool full,
ClearedAllSoftRefs casr(do_clear_all_soft_refs, collector_policy());
const size_t perm_prev_used = perm_gen()->used();
const size_t metadata_prev_used = MetaspaceAux::used_in_bytes();
print_heap_before_gc();
@ -642,9 +541,9 @@ void GenCollectedHeap::do_collection(bool full,
if (PrintGCDetails) {
print_heap_change(gch_prev_used);
// Print perm gen info for full GC with PrintGCDetails flag.
// Print metaspace info for full GC with PrintGCDetails flag.
if (complete) {
print_perm_heap_change(perm_prev_used);
MetaspaceAux::print_metaspace_change(metadata_prev_used);
}
}
@ -654,8 +553,8 @@ void GenCollectedHeap::do_collection(bool full,
}
if (complete) {
// Ask the permanent generation to adjust size for full collections
perm()->compute_new_size();
// Resize the metaspace capacity after full collections
MetaspaceGC::compute_new_size();
update_full_collections_completed();
}
@ -664,6 +563,11 @@ void GenCollectedHeap::do_collection(bool full,
gc_epilogue(complete);
// Delete metaspaces for unloaded class loaders and clean up loader_data graph
if (complete) {
ClassLoaderDataGraph::purge();
}
if (must_restore_marks_for_biased_locking) {
BiasedLocking::restore_marks();
}
@ -692,21 +596,22 @@ void GenCollectedHeap::
gen_process_strong_roots(int level,
bool younger_gens_as_roots,
bool activate_scope,
bool collecting_perm_gen,
bool is_scavenging,
SharedHeap::ScanningOption so,
OopsInGenClosure* not_older_gens,
bool do_code_roots,
OopsInGenClosure* older_gens) {
OopsInGenClosure* older_gens,
KlassClosure* klass_closure) {
// General strong roots.
if (!do_code_roots) {
SharedHeap::process_strong_roots(activate_scope, collecting_perm_gen, so,
not_older_gens, NULL, older_gens);
SharedHeap::process_strong_roots(activate_scope, is_scavenging, so,
not_older_gens, NULL, klass_closure);
} else {
bool do_code_marking = (activate_scope || nmethod::oops_do_marking_is_active());
CodeBlobToOopClosure code_roots(not_older_gens, /*do_marking=*/ do_code_marking);
SharedHeap::process_strong_roots(activate_scope, collecting_perm_gen, so,
not_older_gens, &code_roots, older_gens);
SharedHeap::process_strong_roots(activate_scope, is_scavenging, so,
not_older_gens, &code_roots, klass_closure);
}
if (younger_gens_as_roots) {
@ -748,7 +653,6 @@ oop_since_save_marks_iterate(int level, \
for (int i = level+1; i < n_gens(); i++) { \
_gens[i]->oop_since_save_marks_iterate##nv_suffix(older); \
} \
perm_gen()->oop_since_save_marks_iterate##nv_suffix(older); \
}
ALL_SINCE_SAVE_MARKS_CLOSURES(GCH_SINCE_SAVE_MARKS_ITERATE_DEFN)
@ -759,7 +663,7 @@ bool GenCollectedHeap::no_allocs_since_save_marks(int level) {
for (int i = level; i < _n_gens; i++) {
if (!_gens[i]->no_allocs_since_save_marks()) return false;
}
return perm_gen()->no_allocs_since_save_marks();
return true;
}
bool GenCollectedHeap::supports_inline_contig_alloc() const {
@ -811,27 +715,6 @@ void GenCollectedHeap::collect(GCCause::Cause cause, int max_level) {
collect_locked(cause, max_level);
}
// This interface assumes that it's being called by the
// vm thread. It collects the heap assuming that the
// heap lock is already held and that we are executing in
// the context of the vm thread.
void GenCollectedHeap::collect_as_vm_thread(GCCause::Cause cause) {
assert(Thread::current()->is_VM_thread(), "Precondition#1");
assert(Heap_lock->is_locked(), "Precondition#2");
GCCauseSetter gcs(this, cause);
switch (cause) {
case GCCause::_heap_inspection:
case GCCause::_heap_dump: {
HandleMark hm;
do_full_collection(false, // don't clear all soft refs
n_gens() - 1);
break;
}
default: // XXX FIX ME
ShouldNotReachHere(); // Unexpected use of this function
}
}
void GenCollectedHeap::collect_locked(GCCause::Cause cause) {
// The caller has the Heap_lock
assert(Heap_lock->owned_by_self(), "this thread should own the Heap_lock");
@ -842,9 +725,6 @@ void GenCollectedHeap::collect_locked(GCCause::Cause cause) {
// The Heap_lock is expected to be held on entry.
void GenCollectedHeap::collect_locked(GCCause::Cause cause, int max_level) {
if (_preloading_shared_classes) {
report_out_of_shared_space(SharedPermGen);
}
// Read the GC count while holding the Heap_lock
unsigned int gc_count_before = total_collections();
unsigned int full_gc_count_before = total_full_collections();
@ -860,14 +740,12 @@ void GenCollectedHeap::collect_locked(GCCause::Cause cause, int max_level) {
bool GenCollectedHeap::create_cms_collector() {
assert(((_gens[1]->kind() == Generation::ConcurrentMarkSweep) ||
(_gens[1]->kind() == Generation::ASConcurrentMarkSweep)) &&
_perm_gen->as_gen()->kind() == Generation::ConcurrentMarkSweep,
(_gens[1]->kind() == Generation::ASConcurrentMarkSweep)),
"Unexpected generation kinds");
// Skip two header words in the block content verification
NOT_PRODUCT(_skip_header_HeapWords = CMSCollector::skip_header_HeapWords();)
CMSCollector* collector = new CMSCollector(
(ConcurrentMarkSweepGeneration*)_gens[1],
(ConcurrentMarkSweepGeneration*)_perm_gen->as_gen(),
_rem_set->as_CardTableRS(),
(ConcurrentMarkSweepPolicy*) collector_policy());
@ -896,6 +774,9 @@ void GenCollectedHeap::collect_mostly_concurrent(GCCause::Cause cause) {
}
#endif // SERIALGC
void GenCollectedHeap::do_full_collection(bool clear_all_soft_refs) {
do_full_collection(clear_all_soft_refs, _n_gens - 1);
}
void GenCollectedHeap::do_full_collection(bool clear_all_soft_refs,
int max_level) {
@ -954,7 +835,6 @@ bool GenCollectedHeap::is_in(const void* p) const {
for (int i = 0; i < _n_gens; i++) {
if (_gens[i]->is_in(p)) return true;
}
if (_perm_gen->as_gen()->is_in(p)) return true;
// Otherwise...
return false;
}
@ -965,18 +845,17 @@ bool GenCollectedHeap::is_in(const void* p) const {
bool GenCollectedHeap::is_in_partial_collection(const void* p) {
assert(is_in_reserved(p) || p == NULL,
"Does not work if address is non-null and outside of the heap");
// The order of the generations is young (low addr), old, perm (high addr)
return p < _gens[_n_gens - 2]->reserved().end() && p != NULL;
}
#endif
void GenCollectedHeap::oop_iterate(OopClosure* cl) {
void GenCollectedHeap::oop_iterate(ExtendedOopClosure* cl) {
for (int i = 0; i < _n_gens; i++) {
_gens[i]->oop_iterate(cl);
}
}
void GenCollectedHeap::oop_iterate(MemRegion mr, OopClosure* cl) {
void GenCollectedHeap::oop_iterate(MemRegion mr, ExtendedOopClosure* cl) {
for (int i = 0; i < _n_gens; i++) {
_gens[i]->oop_iterate(mr, cl);
}
@ -986,14 +865,12 @@ void GenCollectedHeap::object_iterate(ObjectClosure* cl) {
for (int i = 0; i < _n_gens; i++) {
_gens[i]->object_iterate(cl);
}
perm_gen()->object_iterate(cl);
}
void GenCollectedHeap::safe_object_iterate(ObjectClosure* cl) {
for (int i = 0; i < _n_gens; i++) {
_gens[i]->safe_object_iterate(cl);
}
perm_gen()->safe_object_iterate(cl);
}
void GenCollectedHeap::object_iterate_since_last_GC(ObjectClosure* cl) {
@ -1007,8 +884,6 @@ Space* GenCollectedHeap::space_containing(const void* addr) const {
Space* res = _gens[i]->space_containing(addr);
if (res != NULL) return res;
}
Space* res = perm_gen()->space_containing(addr);
if (res != NULL) return res;
// Otherwise...
assert(false, "Could not find containing space");
return NULL;
@ -1024,11 +899,6 @@ HeapWord* GenCollectedHeap::block_start(const void* addr) const {
return _gens[i]->block_start(addr);
}
}
if (perm_gen()->is_in_reserved(addr)) {
assert(perm_gen()->is_in(addr),
"addr should be in allocated part of perm gen");
return perm_gen()->block_start(addr);
}
assert(false, "Some generation should contain the address");
return NULL;
}
@ -1042,11 +912,6 @@ size_t GenCollectedHeap::block_size(const HeapWord* addr) const {
return _gens[i]->block_size(addr);
}
}
if (perm_gen()->is_in_reserved(addr)) {
assert(perm_gen()->is_in(addr),
"addr should be in allocated part of perm gen");
return perm_gen()->block_size(addr);
}
assert(false, "Some generation should contain the address");
return 0;
}
@ -1059,9 +924,6 @@ bool GenCollectedHeap::block_is_obj(const HeapWord* addr) const {
return _gens[i]->block_is_obj(addr);
}
}
if (perm_gen()->is_in_reserved(addr)) {
return perm_gen()->block_is_obj(addr);
}
assert(false, "Some generation should contain the address");
return false;
}
@ -1164,7 +1026,6 @@ void GenCollectedHeap::prepare_for_verify() {
ensure_parsability(false); // no need to retire TLABs
GenPrepareForVerifyClosure blk;
generation_iterate(&blk, false);
perm_gen()->prepare_for_verify();
}
@ -1185,11 +1046,10 @@ void GenCollectedHeap::space_iterate(SpaceClosure* cl) {
for (int i = 0; i < _n_gens; i++) {
_gens[i]->space_iterate(cl, true);
}
perm_gen()->space_iterate(cl, true);
}
bool GenCollectedHeap::is_maximal_no_gc() const {
for (int i = 0; i < _n_gens; i++) { // skip perm gen
for (int i = 0; i < _n_gens; i++) {
if (!_gens[i]->is_maximal_no_gc()) {
return false;
}
@ -1201,7 +1061,6 @@ void GenCollectedHeap::save_marks() {
for (int i = 0; i < _n_gens; i++) {
_gens[i]->save_marks();
}
perm_gen()->save_marks();
}
void GenCollectedHeap::compute_new_generation_sizes(int collectedGen) {
@ -1232,10 +1091,6 @@ GCStats* GenCollectedHeap::gc_stats(int level) const {
}
void GenCollectedHeap::verify(bool silent, VerifyOption option /* ignored */) {
if (!silent) {
gclog_or_tty->print("permgen ");
}
perm_gen()->verify();
for (int i = _n_gens-1; i >= 0; i--) {
Generation* g = _gens[i];
if (!silent) {
@ -1254,7 +1109,7 @@ void GenCollectedHeap::print_on(outputStream* st) const {
for (int i = 0; i < _n_gens; i++) {
_gens[i]->print_on(st);
}
perm_gen()->print_on(st);
MetaspaceAux::print_on(st);
}
void GenCollectedHeap::gc_threads_do(ThreadClosure* tc) const {
@ -1302,13 +1157,6 @@ void GenCollectedHeap::print_heap_change(size_t prev_used) const {
}
}
//New method to print perm gen info with PrintGCDetails flag
void GenCollectedHeap::print_perm_heap_change(size_t perm_prev_used) const {
gclog_or_tty->print(", [%s :", perm_gen()->short_name());
perm_gen()->print_heap_change(perm_prev_used);
gclog_or_tty->print("]");
}
class GenGCPrologueClosure: public GenCollectedHeap::GenClosure {
private:
bool _full;
@ -1332,7 +1180,6 @@ void GenCollectedHeap::gc_prologue(bool full) {
// Walk generations
GenGCPrologueClosure blk(full);
generation_iterate(&blk, false); // not old-to-young.
perm_gen()->gc_prologue(full);
};
class GenGCEpilogueClosure: public GenCollectedHeap::GenClosure {
@ -1356,12 +1203,13 @@ void GenCollectedHeap::gc_epilogue(bool full) {
GenGCEpilogueClosure blk(full);
generation_iterate(&blk, false); // not old-to-young.
perm_gen()->gc_epilogue(full);
if (!CleanChunkPoolAsync) {
Chunk::clean_chunk_pool();
}
MetaspaceCounters::update_performance_counters();
always_do_update_barrier = UseConcMarkSweepGC;
};
@ -1378,7 +1226,6 @@ void GenCollectedHeap::record_gen_tops_before_GC() {
if (ZapUnusedHeapArea) {
GenGCSaveTopsBeforeGCClosure blk;
generation_iterate(&blk, false); // not old-to-young.
perm_gen()->record_spaces_top();
}
}
#endif // not PRODUCT
@ -1394,7 +1241,6 @@ void GenCollectedHeap::ensure_parsability(bool retire_tlabs) {
CollectedHeap::ensure_parsability(retire_tlabs);
GenEnsureParsabilityClosure ep_cl;
generation_iterate(&ep_cl, false);
perm_gen()->ensure_parsability();
}
oop GenCollectedHeap::handle_failed_promotion(Generation* gen,
@ -1447,7 +1293,6 @@ jlong GenCollectedHeap::millis_since_last_gc() {
// iterate over generations getting the oldest
// time that a generation was collected
generation_iterate(&tolgc_cl, false);
tolgc_cl.do_generation(perm_gen());
// javaTimeNanos() is guaranteed to be monotonically non-decreasing
// provided the underlying platform provides such a time source