truffle: src/share/vm/memory/genCollectedHeap.cpp comparison

comparison src/share/vm/memory/genCollectedHeap.cpp @ 6725:da91efe96a93

6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>

author	coleenp
date	Sat, 01 Sep 2012 13:25:18 -0400
parents	bbc900c2482a
children	4202510ee0fe

comparison

equal deleted inserted replaced

-:36d1d483d5d6
+:da91efe96a93
 #include "classfile/vmSymbols.hpp"
 #include "code/icBuffer.hpp"
 #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"
 #include "oops/oop.inline.hpp"
 #include "oops/oop.inline2.hpp"
 if (_gen_process_strong_tasks == NULL ||
 !_gen_process_strong_tasks->valid()) {
 vm_exit_during_initialization("Failed necessary allocation.");
 }
 assert(policy != NULL, "Sanity check");
-_preloading_shared_classes = false;
 }
 jint GenCollectedHeap::initialize() {
 CollectedHeap::pre_initialize();
 // The heap must be at least as aligned as generations.
 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.
 char* heap_address;
 size_t total_reserved = 0;
 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");
 return JNI_ENOMEM;
 // It is important to do this in a way such that concurrent readers can't
 // 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()
+size_t actual_heap_size = heap_rs.size();
-- perm_gen_spec->misc_code_size();
 _reserved.set_end((HeapWord*)(heap_rs.base() + actual_heap_size));
 _rem_set = collector_policy()->create_rem_set(_reserved, n_covered_regions);
 set_barrier_set(rem_set()->bs());
 _gch = this;
 for (i = 0; i < _n_gens; i++) {
-ReservedSpace this_rs = heap_rs.first_part(_gen_specs[i]->max_size(),
+ReservedSpace this_rs = heap_rs.first_part(_gen_specs[i]->max_size(), false, false);
-UseSharedSpaces, UseSharedSpaces);
 _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
 // If we are running CMS, create the collector responsible
 // for collecting the CMS generations.
 return JNI_OK;
 }
 char* GenCollectedHeap::allocate(size_t alignment,
-PermanentGenerationSpec* perm_gen_spec,
 size_t* _total_reserved,
 int* _n_covered_regions,
 ReservedSpace* heap_rs){
 const char overflow_msg[] = "The size of the object heap + VM data exceeds "
 "the maximum representable size";
 n_covered_regions += _gen_specs[i]->n_covered_regions();
 }
 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,
+// Needed until the cardtable is fixed to have the right number
-err_msg("Perm size; total_reserved=" SIZE_FORMAT ", pageSize="
+// of covered regions.
-SIZE_FORMAT ", perm gen max=" SIZE_FORMAT, total_reserved,
+n_covered_regions += 2;
-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);
-}
 if (UseLargePages) {
 assert(total_reserved != 0, "total_reserved cannot be 0");
 total_reserved = round_to(total_reserved, os::large_page_size());
 if (total_reserved < os::large_page_size()) {
 vm_exit_during_initialization(overflow_msg);
 }
 }
-// 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,
+*heap_rs = Universe::reserve_heap(total_reserved, alignment);
-UseLargePages, heap_address);
+return heap_rs->base();
-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;
 }
 void GenCollectedHeap::post_initialize() {
 SharedHeap::post_initialize();
 res += _gens[i]->used();
 }
 return res;
 }
-// Save the "used_region" for generations level and lower,
+// Save the "used_region" for generations level and lower.
-// and, if perm is true, for perm gen.
+void GenCollectedHeap::save_used_regions(int level) {
-void GenCollectedHeap::save_used_regions(int level, bool perm) {
 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 {
 size_t res = 0;
 const bool do_clear_all_soft_refs = clear_all_soft_refs ||
 collector_policy()->should_clear_all_soft_refs();
 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();
 {
 FlagSetting fl(_is_gc_active, true);
 }
 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);
 }
 }
 for (int j = max_level_collected; j >= 0; j -= 1) {
 // Adjust generation sizes.
 _gens[j]->compute_new_size();
 }
 if (complete) {
-// Ask the permanent generation to adjust size for full collections
+// Resize the metaspace capacity after full collections
-perm()->compute_new_size();
+MetaspaceGC::compute_new_size();
 update_full_collections_completed();
 }
 // Track memory usage and detect low memory after GC finishes
 MemoryService::track_memory_usage();
 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();
 }
 }
 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,
+SharedHeap::process_strong_roots(activate_scope, is_scavenging, so,
-not_older_gens, NULL, older_gens);
+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,
+SharedHeap::process_strong_roots(activate_scope, is_scavenging, so,
-not_older_gens, &code_roots, older_gens);
+not_older_gens, &code_roots, klass_closure);
 }
 if (younger_gens_as_roots) {
 if (!_gen_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) {
 for (int i = 0; i < level; i++) {
 OopClosureType* older) {                   \
 _gens[level]->oop_since_save_marks_iterate##nv_suffix(cur);           \
 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)
 #undef GCH_SINCE_SAVE_MARKS_ITERATE_DEFN
 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 {
 return _gens[0]->supports_inline_contig_alloc();
 }
 assert(!Heap_lock->owned_by_self(), "this thread should not own the Heap_lock");
 MutexLocker ml(Heap_lock);
 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");
 collect_locked(cause, n_gens() - 1);
 }
 // this is the private collection interface
 // 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();
 {
 MutexUnlocker mu(Heap_lock);  // give up heap lock, execute gets it back
 #ifndef SERIALGC
 bool GenCollectedHeap::create_cms_collector() {
 assert(((_gens[1]->kind() == Generation::ConcurrentMarkSweep) ||
-(_gens[1]->kind() == Generation::ASConcurrentMarkSweep)) &&
+(_gens[1]->kind() == Generation::ASConcurrentMarkSweep)),
-_perm_gen->as_gen()->kind() == Generation::ConcurrentMarkSweep,
 "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());
 if (collector == NULL || !collector->completed_initialization()) {
 if (collector) {
 VMThread::execute(&op);
 }
 }
 #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) {
 int local_max_level;
 if (!incremental_collection_will_fail(false /* don't consult_young */) &&
 // This might be sped up with a cache of the last generation that
 // answered yes.
 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;
 }
 #ifdef ASSERT
 // Don't implement this by using is_in_young().  This method is used
 // in some cases to check that is_in_young() is correct.
 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);
 }
 }
 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) {
 for (int i = 0; i < _n_gens; i++) {
 _gens[i]->object_iterate_since_last_GC(cl);
 Space* GenCollectedHeap::space_containing(const void* addr) const {
 for (int i = 0; i < _n_gens; i++) {
 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;
 }
 assert(_gens[i]->is_in(addr),
 "addr should be in allocated part of generation");
 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;
 }
 size_t GenCollectedHeap::block_size(const HeapWord* addr) const {
 assert(_gens[i]->is_in(addr),
 "addr should be in allocated part of generation");
 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;
 }
 bool GenCollectedHeap::block_is_obj(const HeapWord* addr) const {
 assert(block_start(addr) == addr, "addr must be a block start");
 for (int i = 0; i < _n_gens; i++) {
 if (_gens[i]->is_in_reserved(addr)) {
 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;
 }
 void GenCollectedHeap::prepare_for_verify() {
 ensure_parsability(false);        // no need to retire TLABs
 GenPrepareForVerifyClosure blk;
 generation_iterate(&blk, false);
-perm_gen()->prepare_for_verify();
 }
 void GenCollectedHeap::generation_iterate(GenClosure* cl,
 bool old_to_young) {
 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;
 }
 }
 return true;
 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) {
 for (int i = 0; i <= collectedGen; i++) {
 _gens[i]->compute_new_size();
 GCStats* GenCollectedHeap::gc_stats(int level) const {
 return _gens[level]->gc_stats();
 }
 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) {
 gclog_or_tty->print(g->name());
 gclog_or_tty->print(" ");
 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 {
 if (workers() != NULL) {
 workers()->threads_do(tc);
 "("  SIZE_FORMAT "K)",
 prev_used / K, used() / K, capacity() / K);
 }
 }
-//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;
 public:
 void do_generation(Generation* gen) {
 // Call allocation profiler
 AllocationProfiler::iterate_since_last_gc();
 // Walk generations
 GenGCPrologueClosure blk(full);
 generation_iterate(&blk, false);  // not old-to-young.
-perm_gen()->gc_prologue(full);
 };
 class GenGCEpilogueClosure: public GenCollectedHeap::GenClosure {
 private:
 bool _full;
 resize_all_tlabs();
 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;
 };
 #ifndef PRODUCT
 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
 class GenEnsureParsabilityClosure: public GenCollectedHeap::GenClosure {
 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,
 oop obj,
 size_t obj_size) {
 jlong now = os::javaTimeNanos() / NANOSECS_PER_MILLISEC;
 GenTimeOfLastGCClosure tolgc_cl(now);
 // 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
 // (and it is bug free). So we still have to guard against getting
 // back a time later than 'now'.

Mercurial > hg > truffle

comparison src/share/vm/memory/genCollectedHeap.cpp @ 6725:da91efe96a93