graal-compiler: src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp comparison

comparison src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.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	d2a62e0f25eb
children	e861d44e0c9c

comparison

equal deleted inserted replaced

-:36d1d483d5d6
+:da91efe96a93
 #include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
 #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"
 #include "gc_implementation/parallelScavenge/psMarkSweepDecorator.hpp"
 #include "gc_implementation/parallelScavenge/psOldGen.hpp"
 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
-#include "gc_implementation/parallelScavenge/psPermGen.hpp"
 #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
 #include "gc_implementation/parallelScavenge/psScavenge.hpp"
 #include "gc_implementation/parallelScavenge/psYoungGen.hpp"
 #include "gc_implementation/shared/isGCActiveMark.hpp"
 #include "gc_interface/gcCause.hpp"
 #include "memory/gcLocker.inline.hpp"
 #include "memory/referencePolicy.hpp"
 #include "memory/referenceProcessor.hpp"
-#include "oops/methodDataOop.hpp"
+#include "oops/methodData.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/oop.pcgc.inline.hpp"
 #include "runtime/fprofiler.hpp"
 #include "runtime/safepoint.hpp"
 #include "runtime/vmThread.hpp"
 SpaceInfo PSParallelCompact::_space_info[PSParallelCompact::last_space_id];
 bool      PSParallelCompact::_print_phases = false;
 ReferenceProcessor* PSParallelCompact::_ref_processor = NULL;
-klassOop            PSParallelCompact::_updated_int_array_klass_obj = NULL;
+Klass*              PSParallelCompact::_updated_int_array_klass_obj = NULL;
 double PSParallelCompact::_dwl_mean;
 double PSParallelCompact::_dwl_std_dev;
 double PSParallelCompact::_dwl_first_term;
 double PSParallelCompact::_dwl_adjustment;
 GrowableArray<void*>*   PSParallelCompact::_root_refs_stack = NULL;
 GrowableArray<oop> *    PSParallelCompact::_live_oops = NULL;
 GrowableArray<oop> *    PSParallelCompact::_live_oops_moved_to = NULL;
 GrowableArray<size_t>*  PSParallelCompact::_live_oops_size = NULL;
 size_t                  PSParallelCompact::_live_oops_index = 0;
-size_t                  PSParallelCompact::_live_oops_index_at_perm = 0;
 GrowableArray<void*>*   PSParallelCompact::_other_refs_stack = NULL;
 GrowableArray<void*>*   PSParallelCompact::_adjusted_pointers = NULL;
 bool                    PSParallelCompact::_pointer_tracking = false;
 bool                    PSParallelCompact::_root_tracking = true;
 #endif  // #ifdef ASSERT
 #ifndef PRODUCT
 const char* PSParallelCompact::space_names[] = {
-"perm", "old ", "eden", "from", "to  "
+"old ", "eden", "from", "to  "
 };
 void PSParallelCompact::print_region_ranges()
 {
 tty->print_cr("space  bottom     top        end        new_top");
 }
 void
 print_initial_summary_data(ParallelCompactData& summary_data,
 SpaceInfo* space_info) {
-unsigned int id = PSParallelCompact::perm_space_id;
+unsigned int id = PSParallelCompact::old_space_id;
 const MutableSpace* space;
 do {
 space = space_info[id].space();
 print_initial_summary_data(summary_data, space);
 } while (++id < PSParallelCompact::eden_space_id);
 // First region.
 const size_t beg_ofs = region_offset(addr);
 _region_data[beg_region].add_live_obj(RegionSize - beg_ofs);
-klassOop klass = ((oop)addr)->klass();
+Klass* klass = ((oop)addr)->klass();
 // Middle regions--completely spanned by this object.
 for (size_t region = beg_region + 1; region < end_region; ++region) {
 _region_data[region].set_partial_obj_size(RegionSize);
 _region_data[region].set_partial_obj_addr(addr);
 }
 result += partial_obj_size + live_to_left;
 DEBUG_ONLY(PSParallelCompact::check_new_location(addr, result);)
 return result;
 }
-klassOop ParallelCompactData::calc_new_klass(klassOop old_klass) {
-klassOop updated_klass;
-if (PSParallelCompact::should_update_klass(old_klass)) {
-updated_klass = (klassOop) calc_new_pointer(old_klass);
-} else {
-updated_klass = old_klass;
-}
-return updated_klass;
-}
 #ifdef  ASSERT
 void ParallelCompactData::verify_clear(const PSVirtualSpace* vspace)
 {
 const size_t* const beg = (const size_t*)vspace->committed_low_addr();
 const size_t* const end = (const size_t*)vspace->committed_high_addr();
 void PSParallelCompact::KeepAliveClosure::do_oop(oop* p)       { PSParallelCompact::KeepAliveClosure::do_oop_work(p); }
 void PSParallelCompact::KeepAliveClosure::do_oop(narrowOop* p) { PSParallelCompact::KeepAliveClosure::do_oop_work(p); }
 PSParallelCompact::AdjustPointerClosure PSParallelCompact::_adjust_root_pointer_closure(true);
 PSParallelCompact::AdjustPointerClosure PSParallelCompact::_adjust_pointer_closure(false);
+PSParallelCompact::AdjustKlassClosure PSParallelCompact::_adjust_klass_closure;
 void PSParallelCompact::AdjustPointerClosure::do_oop(oop* p)       { adjust_pointer(p, _is_root); }
 void PSParallelCompact::AdjustPointerClosure::do_oop(narrowOop* p) { adjust_pointer(p, _is_root); }
 void PSParallelCompact::FollowStackClosure::do_void() { _compaction_manager->follow_marking_stacks(); }
-void PSParallelCompact::MarkAndPushClosure::do_oop(oop* p)       { mark_and_push(_compaction_manager, p); }
+void PSParallelCompact::MarkAndPushClosure::do_oop(oop* p)       {
+mark_and_push(_compaction_manager, p);
+}
 void PSParallelCompact::MarkAndPushClosure::do_oop(narrowOop* p) { mark_and_push(_compaction_manager, p); }
+void PSParallelCompact::FollowKlassClosure::do_klass(Klass* klass) {
+klass->oops_do(_mark_and_push_closure);
+}
+void PSParallelCompact::AdjustKlassClosure::do_klass(Klass* klass) {
+klass->oops_do(&PSParallelCompact::_adjust_root_pointer_closure);
+}
 void PSParallelCompact::post_initialize() {
 ParallelScavengeHeap* heap = gc_heap();
 assert(heap->kind() == CollectedHeap::ParallelScavengeHeap, "Sanity");
 {
 memset(&_space_info, 0, sizeof(_space_info));
 ParallelScavengeHeap* heap = gc_heap();
 PSYoungGen* young_gen = heap->young_gen();
-MutableSpace* perm_space = heap->perm_gen()->object_space();
-_space_info[perm_space_id].set_space(perm_space);
 _space_info[old_space_id].set_space(heap->old_gen()->object_space());
 _space_info[eden_space_id].set_space(young_gen->eden_space());
 _space_info[from_space_id].set_space(young_gen->from_space());
 _space_info[to_space_id].set_space(young_gen->to_space());
-_space_info[perm_space_id].set_start_array(heap->perm_gen()->start_array());
 _space_info[old_space_id].set_start_array(heap->old_gen()->start_array());
-_space_info[perm_space_id].set_min_dense_prefix(perm_space->top());
-if (TraceParallelOldGCDensePrefix) {
-tty->print_cr("perm min_dense_prefix=" PTR_FORMAT,
-_space_info[perm_space_id].min_dense_prefix());
-}
 }
 void PSParallelCompact::initialize_dead_wood_limiter()
 {
 const size_t max = 100;
 void fill(ParallelScavengeHeap* heap) {
 _heap_used      = heap->used();
 _young_gen_used = heap->young_gen()->used_in_bytes();
 _old_gen_used   = heap->old_gen()->used_in_bytes();
-_perm_gen_used  = heap->perm_gen()->used_in_bytes();
+_metadata_used  = MetaspaceAux::used_in_bytes();
 };
 size_t heap_used() const      { return _heap_used; }
 size_t young_gen_used() const { return _young_gen_used; }
 size_t old_gen_used() const   { return _old_gen_used; }
-size_t perm_gen_used() const  { return _perm_gen_used; }
+size_t metadata_used() const  { return _metadata_used; }
 private:
 size_t _heap_used;
 size_t _young_gen_used;
 size_t _old_gen_used;
-size_t _perm_gen_used;
+size_t _metadata_used;
 };
 void
 PSParallelCompact::clear_data_covering_space(SpaceId id)
 {
 _space_info[from_space_id].set_space(heap->young_gen()->from_space());
 _space_info[to_space_id].set_space(heap->young_gen()->to_space());
 pre_gc_values->fill(heap);
-ParCompactionManager::reset();
 NOT_PRODUCT(_mark_bitmap.reset_counters());
 DEBUG_ONLY(add_obj_count = add_obj_size = 0;)
 DEBUG_ONLY(mark_bitmap_count = mark_bitmap_size = 0;)
 // Increment the invocation count
 // Verify object start arrays
 if (VerifyObjectStartArray &&
 VerifyBeforeGC) {
 heap->old_gen()->verify_object_start_array();
-heap->perm_gen()->verify_object_start_array();
 }
 DEBUG_ONLY(mark_bitmap()->verify_clear();)
 DEBUG_ONLY(summary_data().verify_clear();)
 void PSParallelCompact::post_compact()
 {
 TraceTime tm("post compact", print_phases(), true, gclog_or_tty);
-for (unsigned int id = perm_space_id; id < last_space_id; ++id) {
+for (unsigned int id = old_space_id; id < last_space_id; ++id) {
 // Clear the marking bitmap, summary data and split info.
 clear_data_covering_space(SpaceId(id));
 // Update top().  Must be done after clearing the bitmap and summary data.
 _space_info[id].publish_new_top();
 }
 BarrierSet* bs = heap->barrier_set();
 if (bs->is_a(BarrierSet::ModRef)) {
 ModRefBarrierSet* modBS = (ModRefBarrierSet*)bs;
 MemRegion old_mr = heap->old_gen()->reserved();
-MemRegion perm_mr = heap->perm_gen()->reserved();
-assert(perm_mr.end() <= old_mr.start(), "Generations out of order");
 if (young_gen_empty) {
-modBS->clear(MemRegion(perm_mr.start(), old_mr.end()));
+modBS->clear(MemRegion(old_mr.start(), old_mr.end()));
 } else {
-modBS->invalidate(MemRegion(perm_mr.start(), old_mr.end()));
+modBS->invalidate(MemRegion(old_mr.start(), old_mr.end()));
 }
 }
+// Delete metaspaces for unloaded class loaders and clean up loader_data graph
+ClassLoaderDataGraph::purge();
 Threads::gc_epilogue();
 CodeCache::gc_epilogue();
 JvmtiExport::gc_epilogue();
 const size_t space_live = pointer_delta(new_top, bottom);
 const size_t space_used = space->used_in_words();
 const size_t space_capacity = space->capacity_in_words();
 const double density = double(space_live) / double(space_capacity);
-const size_t min_percent_free =
+const size_t min_percent_free = MarkSweepDeadRatio;
-id == perm_space_id ? PermMarkSweepDeadRatio : MarkSweepDeadRatio;
 const double limiter = dead_wood_limiter(density, min_percent_free);
 const size_t dead_wood_max = space_used - space_live;
 const size_t dead_wood_limit = MIN2(size_t(space_capacity * limiter),
 dead_wood_max);
 }
 }
 // The amount of live data that will end up in old space (assuming it fits).
 size_t old_space_total_live = 0;
-assert(perm_space_id < old_space_id, "should not count perm data here");
 for (unsigned int id = old_space_id; id < last_space_id; ++id) {
 old_space_total_live += pointer_delta(_space_info[id].new_top(),
 _space_info[id].space()->bottom());
 }
 if (ParallelOldGCSplitALot && old_space_total_live < old_capacity) {
 provoke_split(maximum_compaction);
 }
 #endif // #ifndef PRODUCT
-// Permanent and Old generations.
+// Old generations.
-summarize_space(perm_space_id, maximum_compaction);
 summarize_space(old_space_id, maximum_compaction);
 // Summarize the remaining spaces in the young gen.  The initial target space
 // is the old gen.  If a space does not fit entirely into the target, then the
 // remainder is compacted into the space itself and that space becomes the new
 ParallelScavengeHeap* heap = gc_heap();
 GCCause::Cause gc_cause = heap->gc_cause();
 PSYoungGen* young_gen = heap->young_gen();
 PSOldGen* old_gen = heap->old_gen();
-PSPermGen* perm_gen = heap->perm_gen();
 PSAdaptiveSizePolicy* size_policy = heap->size_policy();
 // The scope of casr should end after code that can change
 // CollectorPolicy::_should_clear_all_soft_refs.
 ClearedAllSoftRefs casr(maximum_heap_compaction,
 if (TraceGen1Time) accumulated_time()->start();
 // Let the size policy know we're starting
 size_policy->major_collection_begin();
-// When collecting the permanent generation methodOops may be moving,
-// so we either have to flush all bcp data or convert it into bci.
 CodeCache::gc_prologue();
 Threads::gc_prologue();
 COMPILER2_PRESENT(DerivedPointerTable::clear());
 // adjust_roots() updates Universe::_intArrayKlassObj which is
 // needed by the compaction for filling holes in the dense prefix.
 adjust_roots();
 compaction_start.update();
-// Does the perm gen always have to be done serially because
-// klasses are used in the update of an object?
-compact_perm(vmthread_cm);
 compact();
 // Reset the mark bitmap, summary data, and do other bookkeeping.  Must be
 // done before resizing.
 post_compact();
 gclog_or_tty->print("AdaptiveSizeStart: ");
 gclog_or_tty->stamp();
 gclog_or_tty->print_cr(" collection: %d ",
 heap->total_collections());
 if (Verbose) {
-gclog_or_tty->print("old_gen_capacity: %d young_gen_capacity: %d"
+gclog_or_tty->print("old_gen_capacity: %d young_gen_capacity: %d",
-" perm_gen_capacity: %d ",
+old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes());
-old_gen->capacity_in_bytes(), young_gen->capacity_in_bytes(),
-perm_gen->capacity_in_bytes());
 }
 }
 // Don't check if the size_policy is ready here.  Let
 // the size_policy check that internally.
 young_gen->to_space()->capacity_in_bytes();
 size_policy->compute_generation_free_space(
 young_gen->used_in_bytes(),
 young_gen->eden_space()->used_in_bytes(),
 old_gen->used_in_bytes(),
-perm_gen->used_in_bytes(),
 young_gen->eden_space()->capacity_in_bytes(),
 old_gen->max_gen_size(),
 max_eden_size,
 true /* full gc*/,
 gc_cause,
 counters->update_young_capacity(young_gen->capacity_in_bytes());
 }
 heap->resize_all_tlabs();
-// We collected the perm gen, so we'll resize it here.
+// Resize the metaspace capactiy after a collection
-perm_gen->compute_new_size(pre_gc_values.perm_gen_used());
+MetaspaceGC::compute_new_size();
 if (TraceGen1Time) accumulated_time()->stop();
 if (PrintGC) {
 if (PrintGCDetails) {
 // No GC timestamp here.  This is after GC so it would be confusing.
 young_gen->print_used_change(pre_gc_values.young_gen_used());
 old_gen->print_used_change(pre_gc_values.old_gen_used());
 heap->print_heap_change(pre_gc_values.heap_used());
-// Print perm gen last (print_heap_change() excludes the perm gen).
+MetaspaceAux::print_metaspace_change(pre_gc_values.metadata_used());
-perm_gen->print_used_change(pre_gc_values.perm_gen_used());
 } else {
 heap->print_heap_change(pre_gc_values.heap_used());
 }
 }
 for (size_t i = 0; i < ParallelGCThreads + 1; ++i) {
 ParCompactionManager* const cm =
 ParCompactionManager::manager_array(int(i));
 assert(cm->marking_stack()->is_empty(),       "should be empty");
 assert(ParCompactionManager::region_list(int(i))->is_empty(), "should be empty");
-assert(cm->revisit_klass_stack()->is_empty(), "should be empty");
 }
 #endif // ASSERT
 if (VerifyAfterGC && heap->total_collections() >= VerifyGCStartAt) {
 HandleMark hm;  // Discard invalid handles created during verification
 // Re-verify object start arrays
 if (VerifyObjectStartArray &&
 VerifyAfterGC) {
 old_gen->verify_object_start_array();
-perm_gen->verify_object_start_array();
 }
 if (ZapUnusedHeapArea) {
 old_gen->object_space()->check_mangled_unused_area_complete();
-perm_gen->object_space()->check_mangled_unused_area_complete();
 }
 NOT_PRODUCT(ref_processor()->verify_no_references_recorded());
 collection_exit.update();
 TaskQueueSetSuper* qset = ParCompactionManager::region_array();
 ParallelTaskTerminator terminator(active_gc_threads, qset);
 PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
 PSParallelCompact::FollowStackClosure follow_stack_closure(cm);
+// Need new claim bits before marking starts.
+ClassLoaderDataGraph::clear_claimed_marks();
 {
 TraceTime tm_m("par mark", print_phases(), true, gclog_or_tty);
 ParallelScavengeHeap::ParStrongRootsScope psrs;
 CodeCache::do_unloading(is_alive_closure(), &mark_and_push_closure,
 purged_class);
 cm->follow_marking_stacks(); // Flush marking stack.
 // Update subklass/sibling/implementor links of live klasses
-// revisit_klass_stack is used in follow_weak_klass_links().
+Klass::clean_weak_klass_links(is_alive_closure());
-follow_weak_klass_links();
-// Revisit memoized MDO's and clear any unmarked weak refs
-follow_mdo_weak_refs();
 // Visit interned string tables and delete unmarked oops
 StringTable::unlink(is_alive_closure());
 // Clean up unreferenced symbols in symbol table.
 SymbolTable::unlink();
 assert(cm->marking_stacks_empty(), "marking stacks should be empty");
+}
+void PSParallelCompact::follow_klass(ParCompactionManager* cm, Klass* klass) {
+ClassLoaderData* cld = klass->class_loader_data();
+assert(cld->has_defined(klass), "inconsistency!");
+// The actual processing of the klass is done when we
+// traverse the list of Klasses in the class loader data.
+PSParallelCompact::follow_class_loader(cm, cld);
+}
+void PSParallelCompact::adjust_klass(ParCompactionManager* cm, Klass* klass) {
+ClassLoaderData* cld = klass->class_loader_data();
+assert(cld->has_defined(klass), "inconsistency!");
+// The actual processing of the klass is done when we
+// traverse the list of Klasses in the class loader data.
+PSParallelCompact::adjust_class_loader(cm, cld);
+}
+void PSParallelCompact::follow_class_loader(ParCompactionManager* cm,
+ClassLoaderData* cld) {
+PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
+PSParallelCompact::FollowKlassClosure follow_klass_closure(&mark_and_push_closure);
+cld->oops_do(&mark_and_push_closure, &follow_klass_closure, true);
+}
+void PSParallelCompact::adjust_class_loader(ParCompactionManager* cm,
+ClassLoaderData* cld) {
+cld->oops_do(PSParallelCompact::adjust_root_pointer_closure(),
+PSParallelCompact::adjust_klass_closure(),
+true);
 }
 // This should be moved to the shared markSweep code!
 class PSAlwaysTrueClosure: public BoolObjectClosure {
 public:
 static PSAlwaysTrueClosure always_true;
 void PSParallelCompact::adjust_roots() {
 // Adjust the pointers to reflect the new locations
 TraceTime tm("adjust roots", print_phases(), true, gclog_or_tty);
+// Need new claim bits when tracing through and adjusting pointers.
+ClassLoaderDataGraph::clear_claimed_marks();
 // General strong roots.
 Universe::oops_do(adjust_root_pointer_closure());
 JNIHandles::oops_do(adjust_root_pointer_closure());   // Global (strong) JNI handles
 Threads::oops_do(adjust_root_pointer_closure(), NULL);
 FlatProfiler::oops_do(adjust_root_pointer_closure());
 Management::oops_do(adjust_root_pointer_closure());
 JvmtiExport::oops_do(adjust_root_pointer_closure());
 // SO_AllClasses
 SystemDictionary::oops_do(adjust_root_pointer_closure());
+ClassLoaderDataGraph::oops_do(adjust_root_pointer_closure(), adjust_klass_closure(), true);
 // Now adjust pointers in remaining weak roots.  (All of which should
 // have been cleared if they pointed to non-surviving objects.)
 // Global (weak) JNI handles
 JNIHandles::weak_oops_do(&always_true, adjust_root_pointer_closure());
 // may have been scanned.  Process them also.
 // Should the reference processor have a span that excludes
 // young gen objects?
 PSScavenge::reference_processor()->weak_oops_do(
 adjust_root_pointer_closure());
-}
-void PSParallelCompact::compact_perm(ParCompactionManager* cm) {
-TraceTime tm("compact perm gen", print_phases(), true, gclog_or_tty);
-// trace("4");
-gc_heap()->perm_gen()->start_array()->reset();
-move_and_update(cm, perm_space_id);
 }
 void PSParallelCompact::enqueue_region_draining_tasks(GCTaskQueue* q,
 uint parallel_gc_threads)
 {
 size_t fillable_regions = 0;   // A count for diagnostic purposes.
 // A region index which corresponds to the tasks created above.
 // "which" must be 0 <= which < task_count
 which = 0;
-for (unsigned int id = to_space_id; id > perm_space_id; --id) {
+// id + 1 is used to test termination so unsigned  can
+// be used with an old_space_id == 0.
+for (unsigned int id = to_space_id; id + 1 > old_space_id; --id) {
 SpaceInfo* const space_info = _space_info + id;
 MutableSpace* const space = space_info->space();
 HeapWord* const new_top = space_info->new_top();
 const size_t beg_region = sd.addr_to_region_idx(space_info->dense_prefix());
 const size_t end_region =
 sd.addr_to_region_idx(sd.region_align_up(new_top));
-assert(end_region > 0, "perm gen cannot be empty");
+for (size_t cur = end_region - 1; cur + 1 > beg_region; --cur) {
-for (size_t cur = end_region - 1; cur >= beg_region; --cur) {
 if (sd.region(cur)->claim_unsafe()) {
 ParCompactionManager::region_list_push(which, cur);
 if (TraceParallelOldGCCompactionPhase && Verbose) {
 const size_t count_mod_8 = fillable_regions & 7;
 gc_task_manager()->execute_and_wait(q);
 #ifdef  ASSERT
 // Verify that all regions have been processed before the deferred updates.
-// Note that perm_space_id is skipped; this type of verification is not
-// valid until the perm gen is compacted by regions.
 for (unsigned int id = old_space_id; id < last_space_id; ++id) {
 verify_complete(SpaceId(id));
 }
 #endif
 }
 print_region_ranges();
 }
 }
 #endif  // #ifdef ASSERT
-void
-PSParallelCompact::follow_weak_klass_links() {
-// All klasses on the revisit stack are marked at this point.
-// Update and follow all subklass, sibling and implementor links.
-// Check all the stacks here even if not all the workers are active.
-// There is no accounting which indicates which stacks might have
-// contents to be followed.
-if (PrintRevisitStats) {
-gclog_or_tty->print_cr("#classes in system dictionary = %d",
-SystemDictionary::number_of_classes());
-}
-for (uint i = 0; i < ParallelGCThreads + 1; i++) {
-ParCompactionManager* cm = ParCompactionManager::manager_array(i);
-KeepAliveClosure keep_alive_closure(cm);
-Stack<Klass*, mtGC>* const rks = cm->revisit_klass_stack();
-if (PrintRevisitStats) {
-gclog_or_tty->print_cr("Revisit klass stack[%u] length = " SIZE_FORMAT,
-i, rks->size());
-}
-while (!rks->is_empty()) {
-Klass* const k = rks->pop();
-k->follow_weak_klass_links(is_alive_closure(), &keep_alive_closure);
-}
-cm->follow_marking_stacks();
-}
-}
-void
-PSParallelCompact::revisit_weak_klass_link(ParCompactionManager* cm, Klass* k) {
-cm->revisit_klass_stack()->push(k);
-}
-void PSParallelCompact::revisit_mdo(ParCompactionManager* cm, DataLayout* p) {
-cm->revisit_mdo_stack()->push(p);
-}
-void PSParallelCompact::follow_mdo_weak_refs() {
-// All strongly reachable oops have been marked at this point;
-// we can visit and clear any weak references from MDO's which
-// we memoized during the strong marking phase.
-if (PrintRevisitStats) {
-gclog_or_tty->print_cr("#classes in system dictionary = %d",
-SystemDictionary::number_of_classes());
-}
-for (uint i = 0; i < ParallelGCThreads + 1; i++) {
-ParCompactionManager* cm = ParCompactionManager::manager_array(i);
-Stack<DataLayout*, mtGC>* rms = cm->revisit_mdo_stack();
-if (PrintRevisitStats) {
-gclog_or_tty->print_cr("Revisit MDO stack[%u] size = " SIZE_FORMAT,
-i, rms->size());
-}
-while (!rms->is_empty()) {
-rms->pop()->follow_weak_refs(is_alive_closure());
-}
-cm->follow_marking_stacks();
-}
-}
 #ifdef VALIDATE_MARK_SWEEP
 void PSParallelCompact::track_adjusted_pointer(void* p, bool isroot) {
 if (!ValidateMarkSweep)
 if (ValidateMarkSweep) {
 _adjusted_pointers->clear();
 _pointer_tracking = true;
 AdjusterTracker checker;
-obj->oop_iterate(&checker);
+obj->oop_iterate_no_header(&checker);
 }
 }
 void PSParallelCompact::check_interior_pointers() {
 guarantee(_adjusted_pointers->length() == 0, "should have processed the same pointers");
 }
 }
-void PSParallelCompact::reset_live_oop_tracking(bool at_perm) {
+void PSParallelCompact::reset_live_oop_tracking() {
 if (ValidateMarkSweep) {
 guarantee((size_t)_live_oops->length() == _live_oops_index, "should be at end of live oops");
-_live_oops_index = at_perm ? _live_oops_index_at_perm : 0;
+_live_oops_index = 0;
 }
 }
 void PSParallelCompact::register_live_oop(oop p, size_t size) {
 // heap, last_space_id is returned.  In debug mode it expects the address to be
 // in the heap and asserts such.
 PSParallelCompact::SpaceId PSParallelCompact::space_id(HeapWord* addr) {
 assert(Universe::heap()->is_in_reserved(addr), "addr not in the heap");
-for (unsigned int id = perm_space_id; id < last_space_id; ++id) {
+for (unsigned int id = old_space_id; id < last_space_id; ++id) {
 if (_space_info[id].space()->contains(addr)) {
 return SpaceId(id);
 }
 }
 ParMarkBitMapClosure::IterationStatus
 UpdateOnlyClosure::do_addr(HeapWord* addr, size_t words) {
 do_addr(addr);
 return ParMarkBitMap::incomplete;
 }
-// Prepare for compaction.  This method is executed once
-// (i.e., by a single thread) before compaction.
-// Save the updated location of the intArrayKlassObj for
-// filling holes in the dense prefix.
-void PSParallelCompact::compact_prologue() {
-_updated_int_array_klass_obj = (klassOop)
-summary_data().calc_new_pointer(Universe::intArrayKlassObj());
-}

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp @ 6725:da91efe96a93