graal-compiler: src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp comparison

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.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	9646b7ff4d14

comparison

equal deleted inserted replaced

-:36d1d483d5d6
+:da91efe96a93
 * questions.
 *
 */
 #include "precompiled.hpp"
+#include "classfile/classLoaderData.hpp"
 #include "classfile/symbolTable.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "code/codeCache.hpp"
 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
 #include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
 }
 // The field "_initiating_occupancy" represents the occupancy percentage
 // at which we trigger a new collection cycle.  Unless explicitly specified
-// via CMSInitiating[Perm]OccupancyFraction (argument "io" below), it
+// via CMSInitiatingOccupancyFraction (argument "io" below), it
 // is calculated by:
 //
 //   Let "f" be MinHeapFreeRatio in
 //
 //    _intiating_occupancy = 100-f +
-//                           f * (CMSTrigger[Perm]Ratio/100)
+//                           f * (CMSTriggerRatio/100)
-//   where CMSTrigger[Perm]Ratio is the argument "tr" below.
+//   where CMSTriggerRatio is the argument "tr" below.
 //
 // That is, if we assume the heap is at its desired maximum occupancy at the
-// end of a collection, we let CMSTrigger[Perm]Ratio of the (purported) free
+// end of a collection, we let CMSTriggerRatio of the (purported) free
 // space be allocated before initiating a new collection cycle.
 //
 void ConcurrentMarkSweepGeneration::init_initiating_occupancy(intx io, intx tr) {
 assert(io <= 100 && tr >= 0 && tr <= 100, "Check the arguments");
 if (io >= 0) {
 &_is_alive_closure,                  // closure for liveness info
 false);                              // next field updates do not need write barrier
 // Initialize the _ref_processor field of CMSGen
 _cmsGen->set_ref_processor(_ref_processor);
-// Allocate a dummy ref processor for perm gen.
-ReferenceProcessor* rp2 = new ReferenceProcessor();
-if (rp2 == NULL) {
-vm_exit_during_initialization("Could not allocate ReferenceProcessor object");
-}
-_permGen->set_ref_processor(rp2);
 }
 }
 CMSAdaptiveSizePolicy* CMSCollector::size_policy() {
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 CMSCollector::Idling;
 bool CMSCollector::_foregroundGCIsActive = false;
 bool CMSCollector::_foregroundGCShouldWait = false;
 CMSCollector::CMSCollector(ConcurrentMarkSweepGeneration* cmsGen,
-ConcurrentMarkSweepGeneration* permGen,
 CardTableRS*                   ct,
 ConcurrentMarkSweepPolicy*     cp):
 _cmsGen(cmsGen),
-_permGen(permGen),
 _ct(ct),
 _ref_processor(NULL),    // will be set later
 _conc_workers(NULL),     // may be set later
 _abort_preclean(false),
 _start_sampling(false),
 _between_prologue_and_epilogue(false),
 _markBitMap(0, Mutex::leaf + 1, "CMS_markBitMap_lock"),
-_perm_gen_verify_bit_map(0, -1 /* no mutex */, "No_lock"),
 _modUnionTable((CardTableModRefBS::card_shift - LogHeapWordSize),
 -1 /* lock-free */, "No_lock" /* dummy */),
 _modUnionClosure(&_modUnionTable),
 _modUnionClosurePar(&_modUnionTable),
-// Adjust my span to cover old (cms) gen and perm gen
+// Adjust my span to cover old (cms) gen
-_span(cmsGen->reserved()._union(permGen->reserved())),
+_span(cmsGen->reserved()),
 // Construct the is_alive_closure with _span & markBitMap
 _is_alive_closure(_span, &_markBitMap),
 _restart_addr(NULL),
 _overflow_list(NULL),
 _stats(cmsGen),
 }
 // Now expand the span and allocate the collection support structures
 // (MUT, marking bit map etc.) to cover both generations subject to
 // collection.
-// First check that _permGen is adjacent to _cmsGen and above it.
-assert(   _cmsGen->reserved().word_size()  > 0
-&& _permGen->reserved().word_size() > 0,
-"generations should not be of zero size");
-assert(_cmsGen->reserved().intersection(_permGen->reserved()).is_empty(),
-"_cmsGen and _permGen should not overlap");
-assert(_cmsGen->reserved().end() == _permGen->reserved().start(),
-"_cmsGen->end() different from _permGen->start()");
 // For use by dirty card to oop closures.
 _cmsGen->cmsSpace()->set_collector(this);
-_permGen->cmsSpace()->set_collector(this);
 // Allocate MUT and marking bit map
 {
 MutexLockerEx x(_markBitMap.lock(), Mutex::_no_safepoint_check_flag);
 if (!_markBitMap.allocate(_span)) {
 assert(_modUnionTable.covers(_span), "_modUnionTable inconsistency?");
 }
 if (!_markStack.allocate(MarkStackSize)) {
 warning("Failed to allocate CMS Marking Stack");
-return;
-}
-if (!_revisitStack.allocate(CMSRevisitStackSize)) {
-warning("Failed to allocate CMS Revisit Stack");
 return;
 }
 // Support for multi-threaded concurrent phases
 if (CMSConcurrentMTEnabled) {
 }
 }
 }
 _cmsGen ->init_initiating_occupancy(CMSInitiatingOccupancyFraction, CMSTriggerRatio);
-_permGen->init_initiating_occupancy(CMSInitiatingPermOccupancyFraction, CMSTriggerPermRatio);
 // Clip CMSBootstrapOccupancy between 0 and 100.
 _bootstrap_occupancy = ((double)MIN2((uintx)100, MAX2((uintx)0, CMSBootstrapOccupancy)))
 /(double)100;
 || (   _survivor_chunk_capacity == 0
 && _survivor_chunk_index == 0),
 "Error");
 // Choose what strong roots should be scanned depending on verification options
-// and perm gen collection mode.
 if (!CMSClassUnloadingEnabled) {
 // If class unloading is disabled we want to include all classes into the root set.
 add_root_scanning_option(SharedHeap::SO_AllClasses);
 } else {
 add_root_scanning_option(SharedHeap::SO_SystemClasses);
 assert(_markBitMap.covers(start, size), "Out of bounds");
 if (_collectorState >= Marking) {
 MutexLockerEx y(_markBitMap.lock(),
 Mutex::_no_safepoint_check_flag);
 // [see comments preceding SweepClosure::do_blk() below for details]
+//
+// Can the P-bits be deleted now?  JJJ
+//
 // 1. need to mark the object as live so it isn't collected
 // 2. need to mark the 2nd bit to indicate the object may be uninitialized
 // 3. need to mark the end of the object so marking, precleaning or sweeping
 //    can skip over uninitialized or unparsable objects. An allocated
 //    object is considered uninitialized for our purposes as long as
-//    its klass word is NULL. (Unparsable objects are those which are
+//    its klass word is NULL.  All old gen objects are parsable
-//    initialized in the sense just described, but whose sizes can still
-//    not be correctly determined. Note that the class of unparsable objects
-//    can only occur in the perm gen. All old gen objects are parsable
 //    as soon as they are initialized.)
 _markBitMap.mark(start);          // object is live
 _markBitMap.mark(start + 1);      // object is potentially uninitialized?
 _markBitMap.mark(start + size - 1);
 // mark end of object
 // -----------------------------------------------------
 // FREE:      klass_word & 1 == 1; mark_word holds block size
 //
 // OBJECT:    klass_word installed; klass_word != 0 && klass_word & 1 == 0;
 //            obj->size() computes correct size
-//            [Perm Gen objects needs to be "parsable" before they can be navigated]
 //
 // TRANSIENT: klass_word == 0; size is indeterminate until we become an OBJECT
 //
 // STATE IDENTIFICATION: (64 bit+COOPS)
 // ------------------------------------
 // FREE:      mark_word & CMS_FREE_BIT == 1; mark_word & ~CMS_FREE_BIT gives block_size
 //
 // OBJECT:    klass_word installed; klass_word != 0;
 //            obj->size() computes correct size
-//            [Perm Gen comment above continues to hold]
 //
 // TRANSIENT: klass_word == 0; size is indeterminate until we become an OBJECT
 //
 //
 // STATE TRANSITION DIAGRAM
 obj->set_mark(m);
 assert(obj->klass_or_null() == NULL, "Object should be uninitialized here.");
 assert(!((FreeChunk*)obj_ptr)->is_free(), "Error, block will look free but show wrong size");
 OrderAccess::storestore();
-if (UseCompressedOops) {
+if (UseCompressedKlassPointers) {
 // Copy gap missed by (aligned) header size calculation below
 obj->set_klass_gap(old->klass_gap());
 }
 if (word_sz > (size_t)oopDesc::header_size()) {
 Copy::aligned_disjoint_words(old_ptr + oopDesc::header_size(),
 CMSParGCThreadState* ps = _par_gc_thread_states[thread_num];
 ParScanWithoutBarrierClosure* dummy_cl = NULL;
 ps->promo.promoted_oops_iterate_nv(dummy_cl);
 }
-// XXXPERM
 bool ConcurrentMarkSweepGeneration::should_collect(bool   full,
 size_t size,
 bool   tlab)
 {
 // We allow a STW collection only if a full
 _cmsGen->contiguous_available());
 gclog_or_tty->print_cr("promotion_rate=%g", stats().promotion_rate());
 gclog_or_tty->print_cr("cms_allocation_rate=%g", stats().cms_allocation_rate());
 gclog_or_tty->print_cr("occupancy=%3.7f", _cmsGen->occupancy());
 gclog_or_tty->print_cr("initiatingOccupancy=%3.7f", _cmsGen->initiating_occupancy());
-gclog_or_tty->print_cr("initiatingPermOccupancy=%3.7f", _permGen->initiating_occupancy());
+gclog_or_tty->print_cr("metadata initialized %d",
+MetaspaceGC::should_concurrent_collect());
 }
 // ------------------------------------------------------------------
 // If the estimated time to complete a cms collection (cms_duration())
 // is less than the estimated time remaining until the cms generation
 return true;
 }
 }
 }
-// Otherwise, we start a collection cycle if either the perm gen or
+// Otherwise, we start a collection cycle if
 // old gen want a collection cycle started. Each may use
 // an appropriate criterion for making this decision.
 // XXX We need to make sure that the gen expansion
 // criterion dovetails well with this. XXX NEED TO FIX THIS
 if (_cmsGen->should_concurrent_collect()) {
 gclog_or_tty->print("CMSCollector: collect because incremental collection will fail ");
 }
 return true;
 }
-if (CMSClassUnloadingEnabled && _permGen->should_concurrent_collect()) {
+if (MetaspaceGC::should_concurrent_collect()) {
-bool res = update_should_unload_classes();
-if (res) {
 if (Verbose && PrintGCDetails) {
-gclog_or_tty->print_cr("CMS perm gen initiated");
+gclog_or_tty->print("CMSCollector: collect for metadata allocation ");
 }
 return true;
 }
-}
 return false;
 }
 // Clear _expansion_cause fields of constituent generations
 void CMSCollector::clear_expansion_cause() {
 _cmsGen->clear_expansion_cause();
-_permGen->clear_expansion_cause();
 }
 // We should be conservative in starting a collection cycle.  To
 // start too eagerly runs the risk of collecting too often in the
 // extreme.  To collect too rarely falls back on full collections,
 //   a concurrent collection (this may be based on criteria such as the
 //   following: the space uses linear allocation and linear allocation is
 //   going to fail, or there is believed to be excessive fragmentation in
 //   the generation, etc... or ...
 // [.(currently done by CMSCollector::shouldConcurrentCollect() only for
-//   the case of the old generation, not the perm generation; see CR 6543076):
+//   the case of the old generation; see CR 6543076):
 //   we may be approaching a point at which allocation requests may fail because
 //   we will be out of sufficient free space given allocation rate estimates.]
 bool ConcurrentMarkSweepGeneration::should_concurrent_collect() const {
 assert_lock_strong(freelistLock());
 clear_expansion_cause();
 _foregroundGCIsActive = false;
 return;
 }
-// Resize the perm generation and the tenured generation
+// Resize the tenured generation
 // after obtaining the free list locks for the
 // two generations.
 void CMSCollector::compute_new_size() {
 assert_locked_or_safepoint(Heap_lock);
 FreelistLocker z(this);
-_permGen->compute_new_size();
+MetaspaceGC::compute_new_size();
 _cmsGen->compute_new_size();
 }
 // A work method used by foreground collection to determine
 // what type of collection (compacting or not, continuing or fresh)
 // all clear.  If we are assuming the collection from an asynchronous
 // collection, clear the _modUnionTable.
 assert(_collectorState != Idling || _modUnionTable.isAllClear(),
 "_modUnionTable should be clear if the baton was not passed");
 _modUnionTable.clear_all();
+assert(_collectorState != Idling || _ct->klass_rem_set()->mod_union_is_clear(),
+"mod union for klasses should be clear if the baton was passed");
+_ct->klass_rem_set()->clear_mod_union();
 // We must adjust the allocation statistics being maintained
 // in the free list space. We do so by reading and clearing
 // the sweep timer and updating the block flux rate estimates below.
 assert(!_intra_sweep_timer.is_active(), "_intra_sweep_timer should be inactive");
 "Should have been NULL'd before baton was passed");
 reset(false /* == !asynch */);
 _cmsGen->reset_after_compaction();
 _concurrent_cycles_since_last_unload = 0;
-if (verifying() && !should_unload_classes()) {
-perm_gen_verify_bit_map()->clear_all();
-}
 // Clear any data recorded in the PLAB chunk arrays.
 if (_survivor_plab_array != NULL) {
 reset_survivor_plab_arrays();
 }
 void CMSCollector::getFreelistLocks() const {
 // Get locks for all free lists in all generations that this
 // collector is responsible for
 _cmsGen->freelistLock()->lock_without_safepoint_check();
-_permGen->freelistLock()->lock_without_safepoint_check();
 }
 void CMSCollector::releaseFreelistLocks() const {
 // Release locks for all free lists in all generations that this
 // collector is responsible for
 _cmsGen->freelistLock()->unlock();
-_permGen->freelistLock()->unlock();
 }
 bool CMSCollector::haveFreelistLocks() const {
 // Check locks for all free lists in all generations that this
 // collector is responsible for
 assert_lock_strong(_cmsGen->freelistLock());
-assert_lock_strong(_permGen->freelistLock());
 PRODUCT_ONLY(ShouldNotReachHere());
 return true;
 }
 // A utility class that is used by the CMS collector to
 assert(_collectorState == Idling, "Should be idling before start.");
 _collectorState = InitialMarking;
 // Reset the expansion cause, now that we are about to begin
 // a new cycle.
 clear_expansion_cause();
+// Clear the MetaspaceGC flag since a concurrent collection
+// is starting but also clear it after the collection.
+MetaspaceGC::set_should_concurrent_collect(false);
 }
 // Decide if we want to enable class unloading as part of the
 // ensuing concurrent GC cycle.
 update_should_unload_classes();
 _full_gc_requested = false;           // acks all outstanding full gc requests
 case Resetting:
 // CMS heap resizing has been completed
 reset(true);
 assert(_collectorState == Idling, "Collector state should "
 "have changed");
+MetaspaceGC::set_should_concurrent_collect(false);
 stats().record_cms_end();
 // Don't move the concurrent_phases_end() and compute_new_size()
 // calls to here because a preempted background collection
 // has it's state set to "Resetting".
 break;
 // work common to all generations it's responsible for. A similar
 // comment applies to the  gc_epilogue()'s.
 // The role of the varaible _between_prologue_and_epilogue is to
 // enforce the invocation protocol.
 void CMSCollector::gc_prologue(bool full) {
-// Call gc_prologue_work() for each CMSGen and PermGen that
+// Call gc_prologue_work() for the CMSGen
 // we are responsible for.
 // The following locking discipline assumes that we are only called
 // when the world is stopped.
 assert(SafepointSynchronize::is_at_safepoint(), "world is stopped assumption");
 // The CMSCollector prologue must call the gc_prologues for the
-// "generations" (including PermGen if any) that it's responsible
+// "generations" that it's responsible
 // for.
 assert(   Thread::current()->is_VM_thread()
 || (   CMSScavengeBeforeRemark
 && Thread::current()->is_ConcurrentGC_thread()),
 }
 // set a bit saying prologue has been called; cleared in epilogue
 _between_prologue_and_epilogue = true;
 // Claim locks for common data structures, then call gc_prologue_work()
-// for each CMSGen and PermGen that we are responsible for.
+// for each CMSGen.
 getFreelistLocks();   // gets free list locks on constituent spaces
 bitMapLock()->lock_without_safepoint_check();
 // Should call gc_prologue_work() for all cms gens we are responsible for
-bool registerClosure =    _collectorState >= Marking
+bool duringMarking =    _collectorState >= Marking
 && _collectorState < Sweeping;
+// The young collections clear the modified oops state, which tells if
+// there are any modified oops in the class. The remark phase also needs
+// that information. Tell the young collection to save the union of all
+// modified klasses.
+if (duringMarking) {
+_ct->klass_rem_set()->set_accumulate_modified_oops(true);
+}
+bool registerClosure = duringMarking;
 ModUnionClosure* muc = CollectedHeap::use_parallel_gc_threads() ?
 &_modUnionClosurePar
 : &_modUnionClosure;
 _cmsGen->gc_prologue_work(full, registerClosure, muc);
-_permGen->gc_prologue_work(full, registerClosure, muc);
 if (!full) {
 stats().record_gc0_begin();
 }
 }
 return;
 }
 assert(haveFreelistLocks(), "must have freelist locks");
 assert_lock_strong(bitMapLock());
+_ct->klass_rem_set()->set_accumulate_modified_oops(false);
 _cmsGen->gc_epilogue_work(full);
-_permGen->gc_epilogue_work(full);
 if (_collectorState == AbortablePreclean || _collectorState == Precleaning) {
 // in case sampling was not already enabled, enable it
 _start_sampling = true;
 }
 // reset _eden_chunk_array so sampling starts afresh
 _eden_chunk_index = 0;
 size_t cms_used   = _cmsGen->cmsSpace()->used();
-size_t perm_used  = _permGen->cmsSpace()->used();
 // update performance counters - this uses a special version of
 // update_counters() that allows the utilization to be passed as a
 // parameter, avoiding multiple calls to used().
 //
 _cmsGen->update_counters(cms_used);
-_permGen->update_counters(perm_used);
 if (CMSIncrementalMode) {
 icms_update_allocation_limits();
 }
 void CMSCollector::verify_after_remark_work_1() {
 ResourceMark rm;
 HandleMark  hm;
 GenCollectedHeap* gch = GenCollectedHeap::heap();
+// Get a clear set of claim bits for the strong roots processing to work with.
+ClassLoaderDataGraph::clear_claimed_marks();
 // Mark from roots one level into CMS
 MarkRefsIntoClosure notOlder(_span, verification_mark_bm());
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 gch->gen_process_strong_roots(_cmsGen->level(),
 true,   // younger gens are roots
 true,   // activate StrongRootsScope
-true,   // collecting perm gen
+false,  // not scavenging
 SharedHeap::ScanningOption(roots_scanning_options()),
 &notOlder,
 true,   // walk code active on stacks
-NULL);
+NULL,
+NULL); // SSS: Provide correct closure
 // Now mark from the roots
-assert(_revisitStack.isEmpty(), "Should be empty");
 MarkFromRootsClosure markFromRootsClosure(this, _span,
-verification_mark_bm(), verification_mark_stack(), &_revisitStack,
+verification_mark_bm(), verification_mark_stack(),
 false /* don't yield */, true /* verifying */);
 assert(_restart_addr == NULL, "Expected pre-condition");
 verification_mark_bm()->iterate(&markFromRootsClosure);
 while (_restart_addr != NULL) {
 // Deal with stack overflow: by restarting at the indicated
 _restart_addr = NULL;
 verification_mark_bm()->iterate(&markFromRootsClosure, ra, _span.end());
 }
 assert(verification_mark_stack()->isEmpty(), "Should have been drained");
 verify_work_stacks_empty();
-// Should reset the revisit stack above, since no class tree
-// surgery is forthcoming.
-_revisitStack.reset(); // throwing away all contents
 // Marking completed -- now verify that each bit marked in
 // verification_mark_bm() is also marked in markBitMap(); flag all
 // errors by printing corresponding objects.
 VerifyMarkedClosure vcl(markBitMap());
 Universe::heap()->print_on(gclog_or_tty);
 fatal("CMS: failed marking verification after remark");
 }
 }
+class VerifyKlassOopsKlassClosure : public KlassClosure {
+class VerifyKlassOopsClosure : public OopClosure {
+CMSBitMap* _bitmap;
+public:
+VerifyKlassOopsClosure(CMSBitMap* bitmap) : _bitmap(bitmap) { }
+void do_oop(oop* p)       { guarantee(*p == NULL || _bitmap->isMarked((HeapWord*) *p), "Should be marked"); }
+void do_oop(narrowOop* p) { ShouldNotReachHere(); }
+} _oop_closure;
+public:
+VerifyKlassOopsKlassClosure(CMSBitMap* bitmap) : _oop_closure(bitmap) {}
+void do_klass(Klass* k) {
+k->oops_do(&_oop_closure);
+}
+};
 void CMSCollector::verify_after_remark_work_2() {
 ResourceMark rm;
 HandleMark  hm;
 GenCollectedHeap* gch = GenCollectedHeap::heap();
+// Get a clear set of claim bits for the strong roots processing to work with.
+ClassLoaderDataGraph::clear_claimed_marks();
 // Mark from roots one level into CMS
 MarkRefsIntoVerifyClosure notOlder(_span, verification_mark_bm(),
 markBitMap());
+CMKlassClosure klass_closure(&notOlder);
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 gch->gen_process_strong_roots(_cmsGen->level(),
 true,   // younger gens are roots
 true,   // activate StrongRootsScope
-true,   // collecting perm gen
+false,  // not scavenging
 SharedHeap::ScanningOption(roots_scanning_options()),
 &notOlder,
 true,   // walk code active on stacks
-NULL);
+NULL,
+&klass_closure);
 // Now mark from the roots
-assert(_revisitStack.isEmpty(), "Should be empty");
 MarkFromRootsVerifyClosure markFromRootsClosure(this, _span,
 verification_mark_bm(), markBitMap(), verification_mark_stack());
 assert(_restart_addr == NULL, "Expected pre-condition");
 verification_mark_bm()->iterate(&markFromRootsClosure);
 while (_restart_addr != NULL) {
 _restart_addr = NULL;
 verification_mark_bm()->iterate(&markFromRootsClosure, ra, _span.end());
 }
 assert(verification_mark_stack()->isEmpty(), "Should have been drained");
 verify_work_stacks_empty();
-// Should reset the revisit stack above, since no class tree
-// surgery is forthcoming.
+VerifyKlassOopsKlassClosure verify_klass_oops(verification_mark_bm());
-_revisitStack.reset(); // throwing away all contents
+ClassLoaderDataGraph::classes_do(&verify_klass_oops);
 // Marking completed -- now verify that each bit marked in
 // verification_mark_bm() is also marked in markBitMap(); flag all
 // errors by printing corresponding objects.
 VerifyMarkedClosure vcl(markBitMap());
 younger_refs_in_space_iterate(_cmsSpace, cl);
 cl->reset_generation();
 }
 void
-ConcurrentMarkSweepGeneration::oop_iterate(MemRegion mr, OopClosure* cl) {
+ConcurrentMarkSweepGeneration::oop_iterate(MemRegion mr, ExtendedOopClosure* cl) {
 if (freelistLock()->owned_by_self()) {
 Generation::oop_iterate(mr, cl);
 } else {
 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
 Generation::oop_iterate(mr, cl);
 }
 }
 void
-ConcurrentMarkSweepGeneration::oop_iterate(OopClosure* cl) {
+ConcurrentMarkSweepGeneration::oop_iterate(ExtendedOopClosure* cl) {
 if (freelistLock()->owned_by_self()) {
 Generation::oop_iterate(cl);
 } else {
 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
 Generation::oop_iterate(cl);
 Generation::safe_object_iterate(cl);
 } else {
 MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag);
 Generation::safe_object_iterate(cl);
 }
-}
-void
-ConcurrentMarkSweepGeneration::pre_adjust_pointers() {
 }
 void
 ConcurrentMarkSweepGeneration::post_compact() {
 }
 }
 }
 void CMSCollector::verify() {
 _cmsGen->verify();
-_permGen->verify();
 }
 #ifndef PRODUCT
 bool CMSCollector::overflow_list_is_empty() const {
 assert(_num_par_pushes >= 0, "Inconsistency");
 assert(no_preserved_marks(), "No preserved marks");
 }
 #endif // PRODUCT
 // Decide if we want to enable class unloading as part of the
-// ensuing concurrent GC cycle. We will collect the perm gen and
+// ensuing concurrent GC cycle. We will collect and
 // unload classes if it's the case that:
 // (1) an explicit gc request has been made and the flag
 //     ExplicitGCInvokesConcurrentAndUnloadsClasses is set, OR
 // (2) (a) class unloading is enabled at the command line, and
-//     (b) (i)   perm gen threshold has been crossed, or
+//     (b) old gen is getting really full
-//         (ii)  old gen is getting really full, or
-//         (iii) the previous N CMS collections did not collect the
-//               perm gen
 // NOTE: Provided there is no change in the state of the heap between
 // calls to this method, it should have idempotent results. Moreover,
 // its results should be monotonically increasing (i.e. going from 0 to 1,
 // but not 1 to 0) between successive calls between which the heap was
 // not collected. For the implementation below, it must thus rely on
 // the property that concurrent_cycles_since_last_unload()
 // will not decrease unless a collection cycle happened and that
-// _permGen->should_concurrent_collect() and _cmsGen->is_too_full() are
+// _cmsGen->is_too_full() are
 // themselves also monotonic in that sense. See check_monotonicity()
 // below.
-bool CMSCollector::update_should_unload_classes() {
+void CMSCollector::update_should_unload_classes() {
 _should_unload_classes = false;
 // Condition 1 above
 if (_full_gc_requested && ExplicitGCInvokesConcurrentAndUnloadsClasses) {
 _should_unload_classes = true;
 } else if (CMSClassUnloadingEnabled) { // Condition 2.a above
 // Disjuncts 2.b.(i,ii,iii) above
 _should_unload_classes = (concurrent_cycles_since_last_unload() >=
 CMSClassUnloadingMaxInterval)
-|| _permGen->should_concurrent_collect()
 || _cmsGen->is_too_full();
 }
-return _should_unload_classes;
 }
 bool ConcurrentMarkSweepGeneration::is_too_full() const {
 bool res = should_concurrent_collect();
 res = res && (occupancy() > (double)CMSIsTooFullPercentage/100.0);
 }
 // Not unloading classes this cycle
 assert(!should_unload_classes(), "Inconsitency!");
 if ((!verifying() || unloaded_classes_last_cycle()) && should_verify) {
-// We were not verifying, or we _were_ unloading classes in the last cycle,
-// AND some verification options are enabled this cycle; in this case,
-// we must make sure that the deadness map is allocated if not already so,
-// and cleared (if already allocated previously --
-// CMSBitMap::sizeInBits() is used to determine if it's allocated).
-if (perm_gen_verify_bit_map()->sizeInBits() == 0) {
-if (!perm_gen_verify_bit_map()->allocate(_permGen->reserved())) {
-warning("Failed to allocate permanent generation verification CMS Bit Map;\n"
-"permanent generation verification disabled");
-return;  // Note that we leave verification disabled, so we'll retry this
-// allocation next cycle. We _could_ remember this failure
-// and skip further attempts and permanently disable verification
-// attempts if that is considered more desirable.
-}
-assert(perm_gen_verify_bit_map()->covers(_permGen->reserved()),
-"_perm_gen_ver_bit_map inconsistency?");
-} else {
-perm_gen_verify_bit_map()->clear_all();
-}
 // Include symbols, strings and code cache elements to prevent their resurrection.
 add_root_scanning_option(rso);
 set_verifying(true);
 } else if (verifying() && !should_verify) {
 // We were verifying, but some verification flags got disabled.
 HeapWord* CMSCollector::block_start(const void* p) const {
 const HeapWord* addr = (HeapWord*)p;
 if (_span.contains(p)) {
 if (_cmsGen->cmsSpace()->is_in_reserved(addr)) {
 return _cmsGen->cmsSpace()->block_start(p);
-} else {
-assert(_permGen->cmsSpace()->is_in_reserved(addr),
-"Inconsistent _span?");
-return _permGen->cmsSpace()->block_start(p);
 }
 }
 return NULL;
 }
 #endif
 gch->save_marks();
 // weak reference processing has not started yet.
 ref_processor()->set_enqueuing_is_done(false);
+// Need to remember all newly created CLDs,
+// so that we can guarantee that the remark finds them.
+ClassLoaderDataGraph::remember_new_clds(true);
+// Whenever a CLD is found, it will be claimed before proceeding to mark
+// the klasses. The claimed marks need to be cleared before marking starts.
+ClassLoaderDataGraph::clear_claimed_marks();
+CMKlassClosure klass_closure(&notOlder);
 {
-// This is not needed. DEBUG_ONLY(RememberKlassesChecker imx(true);)
 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;)
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 gch->gen_process_strong_roots(_cmsGen->level(),
 true,   // younger gens are roots
 true,   // activate StrongRootsScope
-true,   // collecting perm gen
+false,  // not scavenging
 SharedHeap::ScanningOption(roots_scanning_options()),
 &notOlder,
 true,   // walk all of code cache if (so & SO_CodeCache)
-NULL);
+NULL,
+&klass_closure);
 }
 // Clear mod-union table; it will be dirtied in the prologue of
 // CMS generation per each younger generation collection.
 assert(_modUnionTable.isAllClear(),
 "Was cleared in most recent final checkpoint phase"
 " or no bits are set in the gc_prologue before the start of the next "
 "subsequent marking phase.");
+assert(_ct->klass_rem_set()->mod_union_is_clear(), "Must be");
 // Save the end of the used_region of the constituent generations
 // to be used to limit the extent of sweep in each generation.
 save_sweep_limits();
 if (UseAdaptiveSizePolicy) {
 // between concurrent such updates.
 // already have locks
 assert_lock_strong(bitMapLock());
-// Clear the revisit stack, just in case there are any
-// obsolete contents from a short-circuited previous CMS cycle.
-_revisitStack.reset();
 verify_work_stacks_empty();
 verify_overflow_empty();
-assert(_revisitStack.isEmpty(), "tabula rasa");
-DEBUG_ONLY(RememberKlassesChecker cmx(should_unload_classes());)
 bool result = false;
 if (CMSConcurrentMTEnabled && ConcGCThreads > 0) {
 result = do_marking_mt(asynch);
 } else {
 result = do_marking_st(asynch);
 CMSCollector* _collector;
 int           _n_workers;                  // requested/desired # workers
 bool          _asynch;
 bool          _result;
 CompactibleFreeListSpace*  _cms_space;
-CompactibleFreeListSpace* _perm_space;
 char          _pad_front[64];   // padding to ...
 HeapWord*     _global_finger;   // ... avoid sharing cache line
 char          _pad_back[64];
 HeapWord*     _restart_addr;
 CMSConcMarkingTerminatorTerminator _term_term;
 public:
 CMSConcMarkingTask(CMSCollector* collector,
 CompactibleFreeListSpace* cms_space,
-CompactibleFreeListSpace* perm_space,
 bool asynch,
 YieldingFlexibleWorkGang* workers,
 OopTaskQueueSet* task_queues):
 YieldingFlexibleGangTask("Concurrent marking done multi-threaded"),
 _collector(collector),
 _cms_space(cms_space),
-_perm_space(perm_space),
 _asynch(asynch), _n_workers(0), _result(true),
 _task_queues(task_queues),
 _term(_n_workers, task_queues, _collector),
 _bit_map_lock(collector->bitMapLock())
 {
 _requested_size = _n_workers;
 _term.set_task(this);
 _term_term.set_task(this);
-assert(_cms_space->bottom() < _perm_space->bottom(),
-"Finger incorrectly initialized below");
 _restart_addr = _global_finger = _cms_space->bottom();
 }
 OopTaskQueueSet* task_queues()  { return _task_queues; }
 virtual void coordinator_yield();  // stuff done by coordinator
 bool result() { return _result; }
 void reset(HeapWord* ra) {
 assert(_global_finger >= _cms_space->end(),  "Postcondition of ::work(i)");
-assert(_global_finger >= _perm_space->end(), "Postcondition of ::work(i)");
-assert(ra             <  _perm_space->end(), "ra too large");
 _restart_addr = _global_finger = ra;
 _term.reset_for_reuse();
 }
 static bool get_work_from_overflow_stack(CMSMarkStack* ovflw_stk,
 gclog_or_tty->print_cr("Finished cms space scanning in %dth thread: %3.3f sec",
 worker_id, _timer.seconds());
 // XXX: need xxx/xxx type of notation, two timers
 }
-// ... do the same for the _perm_space
-_timer.reset();
-_timer.start();
-do_scan_and_mark(worker_id, _perm_space);
-_timer.stop();
-if (PrintCMSStatistics != 0) {
-gclog_or_tty->print_cr("Finished perm space scanning in %dth thread: %3.3f sec",
-worker_id, _timer.seconds());
-// XXX: need xxx/xxx type of notation, two timers
-}
 // ... do work stealing
 _timer.reset();
 _timer.start();
 do_work_steal(worker_id);
 _timer.stop();
 // Note that under the current task protocol, the
 // following assertion is true even of the spaces
 // expanded since the completion of the concurrent
 // marking. XXX This will likely change under a strict
 // ABORT semantics.
-assert(_global_finger >  _cms_space->end() &&
+// After perm removal the comparison was changed to
-_global_finger >= _perm_space->end(),
+// greater than or equal to from strictly greater than.
+// Before perm removal the highest address sweep would
+// have been at the end of perm gen but now is at the
+// end of the tenured gen.
+assert(_global_finger >=  _cms_space->end(),
 "All tasks have been completed");
 DEBUG_ONLY(_collector->verify_overflow_empty();)
 }
 void CMSConcMarkingTask::bump_global_finger(HeapWord* f) {
 // iteration should be incremental with periodic yields.
 Par_MarkFromRootsClosure cl(this, _collector, my_span,
 &_collector->_markBitMap,
 work_queue(i),
 &_collector->_markStack,
-&_collector->_revisitStack,
 _asynch);
 _collector->_markBitMap.iterate(&cl, my_span.start(), my_span.end());
 } // else nothing to do for this task
 }   // else nothing to do for this task
 }
 // have been bumped up by the thread that claimed the last
 // task.
 pst->all_tasks_completed();
 }
-class Par_ConcMarkingClosure: public Par_KlassRememberingOopClosure {
+class Par_ConcMarkingClosure: public CMSOopClosure {
 private:
+CMSCollector* _collector;
 CMSConcMarkingTask* _task;
 MemRegion     _span;
 CMSBitMap*    _bit_map;
 CMSMarkStack* _overflow_stack;
 OopTaskQueue* _work_queue;
 protected:
 DO_OOP_WORK_DEFN
 public:
 Par_ConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue,
-CMSBitMap* bit_map, CMSMarkStack* overflow_stack,
+CMSBitMap* bit_map, CMSMarkStack* overflow_stack):
-CMSMarkStack* revisit_stack):
+CMSOopClosure(collector->ref_processor()),
-Par_KlassRememberingOopClosure(collector, collector->ref_processor(), revisit_stack),
+_collector(collector),
 _task(task),
 _span(collector->_span),
 _work_queue(work_queue),
 _bit_map(bit_map),
 _overflow_stack(overflow_stack)
 { }
 virtual void do_oop(oop* p);
 virtual void do_oop(narrowOop* p);
 void trim_queue(size_t max);
 void handle_stack_overflow(HeapWord* lost);
 void do_yield_check() {
 if (_task->should_yield()) {
 _task->yield();
 oop new_oop;
 if (_work_queue->pop_local(new_oop)) {
 assert(new_oop->is_oop(), "Should be an oop");
 assert(_bit_map->isMarked((HeapWord*)new_oop), "Grey object");
 assert(_span.contains((HeapWord*)new_oop), "Not in span");
-assert(new_oop->is_parsable(), "Should be parsable");
 new_oop->oop_iterate(this);  // do_oop() above
 do_yield_check();
 }
 }
 }
 void CMSConcMarkingTask::do_work_steal(int i) {
 OopTaskQueue* work_q = work_queue(i);
 oop obj_to_scan;
 CMSBitMap* bm = &(_collector->_markBitMap);
 CMSMarkStack* ovflw = &(_collector->_markStack);
-CMSMarkStack* revisit = &(_collector->_revisitStack);
 int* seed = _collector->hash_seed(i);
-Par_ConcMarkingClosure cl(_collector, this, work_q, bm, ovflw, revisit);
+Par_ConcMarkingClosure cl(_collector, this, work_q, bm, ovflw);
 while (true) {
 cl.trim_queue(0);
 assert(work_q->size() == 0, "Should have been emptied above");
 if (get_work_from_overflow_stack(ovflw, work_q)) {
 // Can't assert below because the work obtained from the
 // This is run by the CMS (coordinator) thread.
 void CMSConcMarkingTask::coordinator_yield() {
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
-DEBUG_ONLY(RememberKlassesChecker mux(false);)
 // First give up the locks, then yield, then re-lock
 // We should probably use a constructor/destructor idiom to
 // do this unlock/lock or modify the MutexUnlocker class to
 // serve our purpose. XXX
 assert_lock_strong(_bit_map_lock);
 conc_workers()->active_workers(),
 Threads::number_of_non_daemon_threads());
 conc_workers()->set_active_workers(num_workers);
 CompactibleFreeListSpace* cms_space  = _cmsGen->cmsSpace();
-CompactibleFreeListSpace* perm_space = _permGen->cmsSpace();
 CMSConcMarkingTask tsk(this,
 cms_space,
-perm_space,
 asynch,
 conc_workers(),
 task_queues());
 // Since the actual number of workers we get may be different
 // from the number we requested above, do we need to do anything different
 // below? In particular, may be we need to subclass the SequantialSubTasksDone
 // class?? XXX
 cms_space ->initialize_sequential_subtasks_for_marking(num_workers);
-perm_space->initialize_sequential_subtasks_for_marking(num_workers);
 // Refs discovery is already non-atomic.
 assert(!ref_processor()->discovery_is_atomic(), "Should be non-atomic");
 assert(ref_processor()->discovery_is_mt(), "Discovery should be MT");
-DEBUG_ONLY(RememberKlassesChecker cmx(should_unload_classes());)
 conc_workers()->start_task(&tsk);
 while (tsk.yielded()) {
 tsk.coordinator_yield();
 conc_workers()->continue_task(&tsk);
 }
 }
 // Adjust the task to restart from _restart_addr
 tsk.reset(_restart_addr);
 cms_space ->initialize_sequential_subtasks_for_marking(num_workers,
 _restart_addr);
-perm_space->initialize_sequential_subtasks_for_marking(num_workers,
-_restart_addr);
 _restart_addr = NULL;
 // Get the workers going again
 conc_workers()->start_task(&tsk);
 while (tsk.yielded()) {
 tsk.coordinator_yield();
 HandleMark   hm;
 // Temporarily make refs discovery single threaded (non-MT)
 ReferenceProcessorMTDiscoveryMutator rp_mut_discovery(ref_processor(), false);
 MarkFromRootsClosure markFromRootsClosure(this, _span, &_markBitMap,
-&_markStack, &_revisitStack, CMSYield && asynch);
+&_markStack, CMSYield && asynch);
 // the last argument to iterate indicates whether the iteration
 // should be incremental with periodic yields.
 _markBitMap.iterate(&markFromRootsClosure);
 // If _restart_addr is non-NULL, a marking stack overflow
 // occurred; we need to do a fresh iteration from the
 // referents.
 if (clean_refs) {
 CMSPrecleanRefsYieldClosure yield_cl(this);
 assert(rp->span().equals(_span), "Spans should be equal");
 CMSKeepAliveClosure keep_alive(this, _span, &_markBitMap,
-&_markStack, &_revisitStack,
+&_markStack, true /* preclean */);
-true /* preclean */);
 CMSDrainMarkingStackClosure complete_trace(this,
 _span, &_markBitMap, &_markStack,
 &keep_alive, true /* preclean */);
 // We don't want this step to interfere with a young
 // collection to proceed promptly. XXX YSR:
 // The code in this method may need further
 // tweaking for better performance and some restructuring
 // for cleaner interfaces.
 rp->preclean_discovered_references(
-rp->is_alive_non_header(), &keep_alive, &complete_trace,
+rp->is_alive_non_header(), &keep_alive, &complete_trace, &yield_cl);
-&yield_cl, should_unload_classes());
 }
 if (clean_survivor) {  // preclean the active survivor space(s)
 assert(_young_gen->kind() == Generation::DefNew ||
 _young_gen->kind() == Generation::ParNew ||
 _young_gen->kind() == Generation::ASParNew,
 "incorrect type for cast");
 DefNewGeneration* dng = (DefNewGeneration*)_young_gen;
 PushAndMarkClosure pam_cl(this, _span, ref_processor(),
 &_markBitMap, &_modUnionTable,
-&_markStack, &_revisitStack,
+&_markStack, true /* precleaning phase */);
-true /* precleaning phase */);
 stopTimer();
 CMSTokenSyncWithLocks ts(true /* is cms thread */,
 bitMapLock());
 startTimer();
 unsigned int before_count =
 GenCollectedHeap::heap()->total_collections();
 SurvivorSpacePrecleanClosure
 sss_cl(this, _span, &_markBitMap, &_markStack,
 &pam_cl, before_count, CMSYield);
-DEBUG_ONLY(RememberKlassesChecker mx(should_unload_classes());)
 dng->from()->object_iterate_careful(&sss_cl);
 dng->to()->object_iterate_careful(&sss_cl);
 }
 MarkRefsIntoAndScanClosure
 mrias_cl(_span, ref_processor(), &_markBitMap, &_modUnionTable,
-&_markStack, &_revisitStack, this, CMSYield,
+&_markStack, this, CMSYield,
 true /* precleaning phase */);
 // CAUTION: The following closure has persistent state that may need to
 // be reset upon a decrease in the sequence of addresses it
 // processes.
 ScanMarkedObjectsAgainCarefullyClosure
 smoac_cl(this, _span,
-&_markBitMap, &_markStack, &_revisitStack, &mrias_cl, CMSYield);
+&_markBitMap, &_markStack, &mrias_cl, CMSYield);
 // Preclean dirty cards in ModUnionTable and CardTable using
 // appropriate convergence criterion;
 // repeat CMSPrecleanIter times unless we find that
 // we are losing.
 size_t numIter, cumNumCards, lastNumCards, curNumCards;
 for (numIter = 0, cumNumCards = lastNumCards = curNumCards = 0;
 numIter < CMSPrecleanIter;
 numIter++, lastNumCards = curNumCards, cumNumCards += curNumCards) {
 curNumCards  = preclean_mod_union_table(_cmsGen, &smoac_cl);
-if (CMSPermGenPrecleaningEnabled) {
-curNumCards  += preclean_mod_union_table(_permGen, &smoac_cl);
-}
 if (Verbose && PrintGCDetails) {
 gclog_or_tty->print(" (modUnionTable: %d cards)", curNumCards);
 }
 // Either there are very few dirty cards, so re-mark
 // pause will be small anyway, or our pre-cleaning isn't
 numIter++;
 cumNumCards += curNumCards;
 break;
 }
 }
+preclean_klasses(&mrias_cl, _cmsGen->freelistLock());
 curNumCards = preclean_card_table(_cmsGen, &smoac_cl);
-if (CMSPermGenPrecleaningEnabled) {
-curNumCards += preclean_card_table(_permGen, &smoac_cl);
-}
 cumNumCards += curNumCards;
 if (PrintGCDetails && PrintCMSStatistics != 0) {
 gclog_or_tty->print_cr(" (cardTable: %d cards, re-scanned %d cards, %d iterations)",
 curNumCards, cumNumCards, numIter);
 }
 ConcurrentMarkSweepGeneration* gen,
 ScanMarkedObjectsAgainCarefullyClosure* cl) {
 verify_work_stacks_empty();
 verify_overflow_empty();
-// Turn off checking for this method but turn it back on
-// selectively.  There are yield points in this method
-// but it is difficult to turn the checking off just around
-// the yield points.  It is simpler to selectively turn
-// it on.
-DEBUG_ONLY(RememberKlassesChecker mux(false);)
 // strategy: starting with the first card, accumulate contiguous
 // ranges of dirty cards; clear these cards, then scan the region
 // covered by these cards.
 // Since all of the MUT is committed ahead, we can just use
 startTimer();
 {
 verify_work_stacks_empty();
 verify_overflow_empty();
 sample_eden();
-DEBUG_ONLY(RememberKlassesChecker mx(should_unload_classes());)
 stop_point =
 gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
 }
 if (stop_point != NULL) {
 // The careful iteration stopped early either because it found an
 // uninitialized object, or because we were in the midst of an
 // "abortable preclean", which should now be aborted. Redirty
 // the bits corresponding to the partially-scanned or unscanned
 // cards. We'll either restart at the next block boundary or
 // abort the preclean.
-assert((CMSPermGenPrecleaningEnabled && (gen == _permGen)) ||
+assert((_collectorState == AbortablePreclean && should_abort_preclean()),
-(_collectorState == AbortablePreclean && should_abort_preclean()),
+"Should only be AbortablePreclean.");
-"Unparsable objects should only be in perm gen.");
 _modUnionTable.mark_range(MemRegion(stop_point, dirtyRegion.end()));
 if (should_abort_preclean()) {
 break; // out of preclean loop
 } else {
 // Compute the next address at which preclean should pick up;
 CMSTokenSyncWithLocks ts(true, gen->freelistLock(), bitMapLock());
 startTimer();
 sample_eden();
 verify_work_stacks_empty();
 verify_overflow_empty();
-DEBUG_ONLY(RememberKlassesChecker mx(should_unload_classes());)
 HeapWord* stop_point =
 gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
 if (stop_point != NULL) {
-// The careful iteration stopped early because it found an
+assert((_collectorState == AbortablePreclean && should_abort_preclean()),
-// uninitialized object.  Redirty the bits corresponding to the
+"Should only be AbortablePreclean.");
-// partially-scanned or unscanned cards, and start again at the
-// next block boundary.
-assert(CMSPermGenPrecleaningEnabled ||
-(_collectorState == AbortablePreclean && should_abort_preclean()),
-"Unparsable objects should only be in perm gen.");
 _ct->ct_bs()->invalidate(MemRegion(stop_point, dirtyRegion.end()));
 if (should_abort_preclean()) {
 break; // out of preclean loop
 } else {
 // Compute the next address at which preclean should pick up.
 }
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
 return cumNumDirtyCards;
+}
+class PrecleanKlassClosure : public KlassClosure {
+CMKlassClosure _cm_klass_closure;
+public:
+PrecleanKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {}
+void do_klass(Klass* k) {
+if (k->has_accumulated_modified_oops()) {
+k->clear_accumulated_modified_oops();
+_cm_klass_closure.do_klass(k);
+}
+}
+};
+// The freelist lock is needed to prevent asserts, is it really needed?
+void CMSCollector::preclean_klasses(MarkRefsIntoAndScanClosure* cl, Mutex* freelistLock) {
+cl->set_freelistLock(freelistLock);
+CMSTokenSyncWithLocks ts(true, freelistLock, bitMapLock());
+// SSS: Add equivalent to ScanMarkedObjectsAgainCarefullyClosure::do_yield_check and should_abort_preclean?
+// SSS: We should probably check if precleaning should be aborted, at suitable intervals?
+PrecleanKlassClosure preclean_klass_closure(cl);
+ClassLoaderDataGraph::classes_do(&preclean_klass_closure);
+verify_work_stacks_empty();
+verify_overflow_empty();
 }
 void CMSCollector::checkpointRootsFinal(bool asynch,
 bool clear_all_soft_refs, bool init_mark_was_synchronous) {
 assert(_collectorState == FinalMarking, "incorrect state transition?");
 CodeCache::gc_prologue();
 }
 assert(haveFreelistLocks(), "must have free list locks");
 assert_lock_strong(bitMapLock());
-DEBUG_ONLY(RememberKlassesChecker fmx(should_unload_classes());)
 if (!init_mark_was_synchronous) {
 // We might assume that we need not fill TLAB's when
 // CMSScavengeBeforeRemark is set, because we may have just done
 // a scavenge which would have filled all TLAB's -- and besides
 // Eden would be empty. This however may not always be the case --
 }
 }
 _markStack._hit_limit = 0;
 _markStack._failed_double = 0;
-// Check that all the klasses have been checked
-assert(_revisitStack.isEmpty(), "Not all klasses revisited");
 if ((VerifyAfterGC || VerifyDuringGC) &&
 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
 verify_after_remark();
 }
 // Change under the freelistLocks.
 _collectorState = Sweeping;
 // Call isAllClear() under bitMapLock
-assert(_modUnionTable.isAllClear(), "Should be clear by end of the"
+assert(_modUnionTable.isAllClear(),
-" final marking");
+"Should be clear by end of the final marking");
+assert(_ct->klass_rem_set()->mod_union_is_clear(),
+"Should be clear by end of the final marking");
 if (UseAdaptiveSizePolicy) {
 size_policy()->checkpoint_roots_final_end(gch->gc_cause());
 }
 }
 // Parallel remark task
 class CMSParRemarkTask: public AbstractGangTask {
 CMSCollector* _collector;
 int           _n_workers;
 CompactibleFreeListSpace* _cms_space;
-CompactibleFreeListSpace* _perm_space;
 // The per-thread work queues, available here for stealing.
 OopTaskQueueSet*       _task_queues;
 ParallelTaskTerminator _term;
 public:
 // A value of 0 passed to n_workers will cause the number of
 // workers to be taken from the active workers in the work gang.
 CMSParRemarkTask(CMSCollector* collector,
 CompactibleFreeListSpace* cms_space,
-CompactibleFreeListSpace* perm_space,
 int n_workers, FlexibleWorkGang* workers,
 OopTaskQueueSet* task_queues):
 AbstractGangTask("Rescan roots and grey objects in parallel"),
 _collector(collector),
-_cms_space(cms_space), _perm_space(perm_space),
+_cms_space(cms_space),
 _n_workers(n_workers),
 _task_queues(task_queues),
 _term(n_workers, task_queues) { }
 OopTaskQueueSet* task_queues() { return _task_queues; }
 void do_dirty_card_rescan_tasks(CompactibleFreeListSpace* sp, int i,
 Par_MarkRefsIntoAndScanClosure* cl);
 // ... work stealing for the above
 void do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, int* seed);
+};
+class RemarkKlassClosure : public KlassClosure {
+CMKlassClosure _cm_klass_closure;
+public:
+RemarkKlassClosure(OopClosure* oop_closure) : _cm_klass_closure(oop_closure) {}
+void do_klass(Klass* k) {
+// Check if we have modified any oops in the Klass during the concurrent marking.
+if (k->has_accumulated_modified_oops()) {
+k->clear_accumulated_modified_oops();
+// We could have transfered the current modified marks to the accumulated marks,
+// like we do with the Card Table to Mod Union Table. But it's not really necessary.
+} else if (k->has_modified_oops()) {
+// Don't clear anything, this info is needed by the next young collection.
+} else {
+// No modified oops in the Klass.
+return;
+}
+// The klass has modified fields, need to scan the klass.
+_cm_klass_closure.do_klass(k);
+}
 };
 // work_queue(i) is passed to the closure
 // Par_MarkRefsIntoAndScanClosure.  The "i" parameter
 // also is passed to do_dirty_card_rescan_tasks() and to
 _timer.start();
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 Par_MarkRefsIntoAndScanClosure par_mrias_cl(_collector,
 _collector->_span, _collector->ref_processor(),
 &(_collector->_markBitMap),
-work_queue(worker_id), &(_collector->_revisitStack));
+work_queue(worker_id));
 // Rescan young gen roots first since these are likely
 // coarsely partitioned and may, on that account, constitute
 // the critical path; thus, it's best to start off that
 // work first.
 _timer.reset();
 _timer.start();
 gch->gen_process_strong_roots(_collector->_cmsGen->level(),
 false,     // yg was scanned above
 false,     // this is parallel code
-true,      // collecting perm gen
+false,     // not scavenging
 SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
 &par_mrias_cl,
 true,   // walk all of code cache if (so & SO_CodeCache)
-NULL);
+NULL,
+NULL);     // The dirty klasses will be handled below
 assert(_collector->should_unload_classes()
 || (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_CodeCache),
 "if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops");
 _timer.stop();
 if (PrintCMSStatistics != 0) {
 gclog_or_tty->print_cr(
 "Finished remaining root rescan work in %dth thread: %3.3f sec",
 worker_id, _timer.seconds());
 }
+// ---------- unhandled CLD scanning ----------
+if (worker_id == 0) { // Single threaded at the moment.
+_timer.reset();
+_timer.start();
+// Scan all new class loader data objects and new dependencies that were
+// introduced during concurrent marking.
+ResourceMark rm;
+GrowableArray<ClassLoaderData*>* array = ClassLoaderDataGraph::new_clds();
+for (int i = 0; i < array->length(); i++) {
+par_mrias_cl.do_class_loader_data(array->at(i));
+}
+// We don't need to keep track of new CLDs anymore.
+ClassLoaderDataGraph::remember_new_clds(false);
+_timer.stop();
+if (PrintCMSStatistics != 0) {
+gclog_or_tty->print_cr(
+"Finished unhandled CLD scanning work in %dth thread: %3.3f sec",
+worker_id, _timer.seconds());
+}
+}
+// ---------- dirty klass scanning ----------
+if (worker_id == 0) { // Single threaded at the moment.
+_timer.reset();
+_timer.start();
+// Scan all classes that was dirtied during the concurrent marking phase.
+RemarkKlassClosure remark_klass_closure(&par_mrias_cl);
+ClassLoaderDataGraph::classes_do(&remark_klass_closure);
+_timer.stop();
+if (PrintCMSStatistics != 0) {
+gclog_or_tty->print_cr(
+"Finished dirty klass scanning work in %dth thread: %3.3f sec",
+worker_id, _timer.seconds());
+}
+}
+// We might have added oops to ClassLoaderData::_handles during the
+// concurrent marking phase. These oops point to newly allocated objects
+// that are guaranteed to be kept alive. Either by the direct allocation
+// code, or when the young collector processes the strong roots. Hence,
+// we don't have to revisit the _handles block during the remark phase.
 // ---------- rescan dirty cards ------------
 _timer.reset();
 _timer.start();
 // Do the rescan tasks for each of the two spaces
-// (cms_space and perm_space) in turn.
+// (cms_space) in turn.
 // "worker_id" is passed to select the task_queue for "worker_id"
 do_dirty_card_rescan_tasks(_cms_space, worker_id, &par_mrias_cl);
-do_dirty_card_rescan_tasks(_perm_space, worker_id, &par_mrias_cl);
 _timer.stop();
 if (PrintCMSStatistics != 0) {
 gclog_or_tty->print_cr(
 "Finished dirty card rescan work in %dth thread: %3.3f sec",
 worker_id, _timer.seconds());
 // more work chunks. Such objects would potentially be scanned
 // several times redundantly. Work on 4756801 should try and
 // address that performance anomaly if at all possible. XXX
 MemRegion  full_span  = _collector->_span;
 CMSBitMap* bm    = &(_collector->_markBitMap);     // shared
-CMSMarkStack* rs = &(_collector->_revisitStack);   // shared
 MarkFromDirtyCardsClosure
 greyRescanClosure(_collector, full_span, // entire span of interest
-sp, bm, work_q, rs, cl);
+sp, bm, work_q, cl);
 SequentialSubTasksDone* pst = sp->conc_par_seq_tasks();
 assert(pst->valid(), "Uninitialized use?");
 uint nth_task = 0;
 const int alignment = CardTableModRefBS::card_size * BitsPerWord;
 assert(n_workers > 0, "Should have been set during scavenge");
 n_workers = ParallelGCThreads;
 workers->set_active_workers(n_workers);
 }
 CompactibleFreeListSpace* cms_space  = _cmsGen->cmsSpace();
-CompactibleFreeListSpace* perm_space = _permGen->cmsSpace();
 CMSParRemarkTask tsk(this,
-cms_space, perm_space,
+cms_space,
 n_workers, workers, task_queues());
 // Set up for parallel process_strong_roots work.
 gch->set_par_threads(n_workers);
 // We won't be iterating over the cards in the card table updating
 // The dirty card rescan work is broken up into a "sequence"
 // of parallel tasks (per constituent space) that are dynamically
 // claimed by the parallel threads.
 cms_space->initialize_sequential_subtasks_for_rescan(n_workers);
-perm_space->initialize_sequential_subtasks_for_rescan(n_workers);
 // It turns out that even when we're using 1 thread, doing the work in a
 // separate thread causes wide variance in run times.  We can't help this
 // in the multi-threaded case, but we special-case n=1 here to get
 // repeatable measurements of the 1-thread overhead of the parallel code.
 } else {
 ReferenceProcessorMTDiscoveryMutator mt(ref_processor(), false);
 GenCollectedHeap::StrongRootsScope srs(gch);
 tsk.work(0);
 }
 gch->set_par_threads(0);  // 0 ==> non-parallel.
 // restore, single-threaded for now, any preserved marks
 // as a result of work_q overflow
 restore_preserved_marks_if_any();
 }
 HandleMark   hm;
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 ReferenceProcessorMTDiscoveryMutator mt(ref_processor(), false);
 MarkRefsIntoAndScanClosure
-mrias_cl(_span, ref_processor(), &_markBitMap, &_modUnionTable,
+mrias_cl(_span, ref_processor(), &_markBitMap, NULL /* not precleaning */,
-&_markStack, &_revisitStack, this,
+&_markStack, this,
 false /* should_yield */, false /* not precleaning */);
 MarkFromDirtyCardsClosure
 markFromDirtyCardsClosure(this, _span,
 NULL,  // space is set further below
-&_markBitMap, &_markStack, &_revisitStack,
+&_markBitMap, &_markStack, &mrias_cl);
-&mrias_cl);
 {
 TraceTime t("grey object rescan", PrintGCDetails, false, gclog_or_tty);
 // Iterate over the dirty cards, setting the corresponding bits in the
 // mod union table.
 {
 ModUnionClosure modUnionClosure(&_modUnionTable);
 _ct->ct_bs()->dirty_card_iterate(
 _cmsGen->used_region(),
-&modUnionClosure);
-_ct->ct_bs()->dirty_card_iterate(
-_permGen->used_region(),
 &modUnionClosure);
 }
 // Having transferred these marks into the modUnionTable, we just need
 // to rescan the marked objects on the dirty cards in the modUnionTable.
 // The initial marking may have been done during an asynchronous
 if (PrintCMSStatistics != 0) {
 gclog_or_tty->print(" (re-scanned "SIZE_FORMAT" dirty cards in cms gen) ",
 markFromDirtyCardsClosure.num_dirty_cards());
 }
 }
-{
-// .. and then repeat for dirty cards in perm gen
-markFromDirtyCardsClosure.set_space(_permGen->cmsSpace());
-MemRegion ur = _permGen->used_region();
-HeapWord* lb = ur.start();
-HeapWord* ub = (HeapWord*)round_to((intptr_t)ur.end(), alignment);
-MemRegion perm_span(lb, ub);
-_modUnionTable.dirty_range_iterate_clear(perm_span,
-&markFromDirtyCardsClosure);
-verify_work_stacks_empty();
-if (PrintCMSStatistics != 0) {
-gclog_or_tty->print(" (re-scanned "SIZE_FORMAT" dirty cards in perm gen) ",
-markFromDirtyCardsClosure.num_dirty_cards());
-}
-}
 }
 if (VerifyDuringGC &&
 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
 HandleMark hm;  // Discard invalid handles created during verification
 Universe::verify(true);
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
 GenCollectedHeap::StrongRootsScope srs(gch);
 gch->gen_process_strong_roots(_cmsGen->level(),
 true,  // younger gens as roots
 false, // use the local StrongRootsScope
-true,  // collecting perm gen
+false, // not scavenging
 SharedHeap::ScanningOption(roots_scanning_options()),
 &mrias_cl,
 true,   // walk code active on stacks
-NULL);
+NULL,
+NULL);  // The dirty klasses will be handled below
 assert(should_unload_classes()
 || (roots_scanning_options() & SharedHeap::SO_CodeCache),
 "if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops");
 }
+{
+TraceTime t("visit unhandled CLDs", PrintGCDetails, false, gclog_or_tty);
+verify_work_stacks_empty();
+// Scan all class loader data objects that might have been introduced
+// during concurrent marking.
+ResourceMark rm;
+GrowableArray<ClassLoaderData*>* array = ClassLoaderDataGraph::new_clds();
+for (int i = 0; i < array->length(); i++) {
+mrias_cl.do_class_loader_data(array->at(i));
+}
+// We don't need to keep track of new CLDs anymore.
+ClassLoaderDataGraph::remember_new_clds(false);
+verify_work_stacks_empty();
+}
+{
+TraceTime t("dirty klass scan", PrintGCDetails, false, gclog_or_tty);
+verify_work_stacks_empty();
+RemarkKlassClosure remark_klass_closure(&mrias_cl);
+ClassLoaderDataGraph::classes_do(&remark_klass_closure);
+verify_work_stacks_empty();
+}
+// We might have added oops to ClassLoaderData::_handles during the
+// concurrent marking phase. These oops point to newly allocated objects
+// that are guaranteed to be kept alive. Either by the direct allocation
+// code, or when the young collector processes the strong roots. Hence,
+// we don't have to revisit the _handles block during the remark phase.
 verify_work_stacks_empty();
 // Restore evacuated mark words, if any, used for overflow list links
 if (!CMSOverflowEarlyRestoration) {
 restore_preserved_marks_if_any();
 }
 void CMSRefProcTaskProxy::work(uint worker_id) {
 assert(_collector->_span.equals(_span), "Inconsistency in _span");
 CMSParKeepAliveClosure par_keep_alive(_collector, _span,
 _mark_bit_map,
-&_collector->_revisitStack,
 work_queue(worker_id));
 CMSParDrainMarkingStackClosure par_drain_stack(_collector, _span,
 _mark_bit_map,
-&_collector->_revisitStack,
 work_queue(worker_id));
 CMSIsAliveClosure is_alive_closure(_span, _mark_bit_map);
 _task.work(worker_id, is_alive_closure, par_keep_alive, par_drain_stack);
 if (_task.marks_oops_alive()) {
 do_work_steal(worker_id, &par_drain_stack, &par_keep_alive,
 _task.work(worker_id);
 }
 };
 CMSParKeepAliveClosure::CMSParKeepAliveClosure(CMSCollector* collector,
-MemRegion span, CMSBitMap* bit_map, CMSMarkStack* revisit_stack,
+MemRegion span, CMSBitMap* bit_map, OopTaskQueue* work_queue):
-OopTaskQueue* work_queue):
-Par_KlassRememberingOopClosure(collector, NULL, revisit_stack),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue),
-_mark_and_push(collector, span, bit_map, revisit_stack, work_queue),
+_mark_and_push(collector, span, bit_map, work_queue),
 _low_water_mark(MIN2((uint)(work_queue->max_elems()/4),
 (uint)(CMSWorkQueueDrainThreshold * ParallelGCThreads)))
 { }
 // . see if we can share work_queues with ParNew? XXX
 // Process weak references.
 rp->setup_policy(clear_all_soft_refs);
 verify_work_stacks_empty();
 CMSKeepAliveClosure cmsKeepAliveClosure(this, _span, &_markBitMap,
-&_markStack, &_revisitStack,
+&_markStack, false /* !preclean */);
-false /* !preclean */);
 CMSDrainMarkingStackClosure cmsDrainMarkingStackClosure(this,
 _span, &_markBitMap, &_markStack,
 &cmsKeepAliveClosure, false /* !preclean */);
 {
 TraceTime t("weak refs processing", PrintGCDetails, false, gclog_or_tty);
 cmsDrainMarkingStackClosure.do_void();
 verify_work_stacks_empty();
 // Update subklass/sibling/implementor links in KlassKlass descendants
-assert(!_revisitStack.isEmpty(), "revisit stack should not be empty");
+Klass::clean_weak_klass_links(&_is_alive_closure);
-oop k;
+// Nothing should have been pushed onto the working stacks.
-while ((k = _revisitStack.pop()) != NULL) {
-((Klass*)(oopDesc*)k)->follow_weak_klass_links(
-&_is_alive_closure,
-&cmsKeepAliveClosure);
-}
-assert(!ClassUnloading ||
-(_markStack.isEmpty() && overflow_list_is_empty()),
-"Should not have found new reachable objects");
-assert(_revisitStack.isEmpty(), "revisit stack should have been drained");
-cmsDrainMarkingStackClosure.do_void();
 verify_work_stacks_empty();
 }
 {
 TraceTime t("scrub symbol table", PrintGCDetails, false, gclog_or_tty);
 // Clean up unreferenced symbols in symbol table.
 SymbolTable::unlink();
 }
 }
-if (should_unload_classes() || !JavaObjectsInPerm) {
+// CMS doesn't use the StringTable as hard roots when class unloading is turned off.
+// Need to check if we really scanned the StringTable.
+if ((roots_scanning_options() & SharedHeap::SO_Strings) == 0) {
 TraceTime t("scrub string table", PrintGCDetails, false, gclog_or_tty);
 // Now clean up stale oops in StringTable
 StringTable::unlink(&_is_alive_closure);
 }
 _inter_sweep_timer.stop();
 _inter_sweep_estimate.sample(_inter_sweep_timer.seconds());
 size_policy()->avg_cms_free_at_sweep()->sample(_cmsGen->free());
-// PermGen verification support: If perm gen sweeping is disabled in
-// this cycle, we preserve the perm gen object "deadness" information
-// in the perm_gen_verify_bit_map. In order to do that we traverse
-// all blocks in perm gen and mark all dead objects.
-if (verifying() && !should_unload_classes()) {
-assert(perm_gen_verify_bit_map()->sizeInBits() != 0,
-"Should have already been allocated");
-MarkDeadObjectsClosure mdo(this, _permGen->cmsSpace(),
-markBitMap(), perm_gen_verify_bit_map());
-if (asynch) {
-CMSTokenSyncWithLocks ts(true, _permGen->freelistLock(),
-bitMapLock());
-_permGen->cmsSpace()->blk_iterate(&mdo);
-} else {
-// In the case of synchronous sweep, we already have
-// the requisite locks/tokens.
-_permGen->cmsSpace()->blk_iterate(&mdo);
-}
-}
 assert(!_intra_sweep_timer.is_active(), "Should not be active");
 _intra_sweep_timer.reset();
 _intra_sweep_timer.start();
 if (asynch) {
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
 CMSPhaseAccounting pa(this, "sweep", !PrintGCDetails);
-// First sweep the old gen then the perm gen
+// First sweep the old gen
 {
 CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock(),
 bitMapLock());
 sweepWork(_cmsGen, asynch);
-}
-// Now repeat for perm gen
-if (should_unload_classes()) {
-CMSTokenSyncWithLocks ts(true, _permGen->freelistLock(),
-bitMapLock());
-sweepWork(_permGen, asynch);
 }
 // Update Universe::_heap_*_at_gc figures.
 // We need all the free list locks to make the abstract state
 // transition from Sweeping to Resetting. See detailed note
 // further below.
 {
-CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock(),
+CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock());
-_permGen->freelistLock());
 // Update heap occupancy information which is used as
 // input to soft ref clearing policy at the next gc.
 Universe::update_heap_info_at_gc();
 _collectorState = Resizing;
 }
 } else {
 // already have needed locks
 sweepWork(_cmsGen,  asynch);
-if (should_unload_classes()) {
-sweepWork(_permGen, asynch);
-}
 // Update heap occupancy information which is used as
 // input to soft ref clearing policy at the next gc.
 Universe::update_heap_info_at_gc();
 _collectorState = Resizing;
 }
 }
 HeapWord* CMSCollector::next_card_start_after_block(HeapWord* addr) const {
 size_t sz = 0;
 oop p = (oop)addr;
-if (p->klass_or_null() != NULL && p->is_parsable()) {
+if (p->klass_or_null() != NULL) {
 sz = CompactibleFreeListSpace::adjustObjectSize(p->size());
 } else {
 sz = block_size_using_printezis_bits(addr);
 }
 assert(sz > 0, "size must be nonzero");
 // should refactor and consolidate common code.
 // This closure is used to mark refs into the CMS generation in
 // the CMS bit map. Called at the first checkpoint. This closure
 // assumes that we do not need to re-mark dirty cards; if the CMS
-// generation on which this is used is not an oldest (modulo perm gen)
+// generation on which this is used is not an oldest
 // generation then this will lose younger_gen cards!
 MarkRefsIntoClosure::MarkRefsIntoClosure(
 MemRegion span, CMSBitMap* bitMap):
 _span(span),
 MarkRefsIntoAndScanClosure::MarkRefsIntoAndScanClosure(MemRegion span,
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
 CMSBitMap* mod_union_table,
 CMSMarkStack*  mark_stack,
-CMSMarkStack*  revisit_stack,
 CMSCollector* collector,
 bool should_yield,
 bool concurrent_precleaning):
 _collector(collector),
 _span(span),
 _bit_map(bit_map),
 _mark_stack(mark_stack),
 _pushAndMarkClosure(collector, span, rp, bit_map, mod_union_table,
-mark_stack, revisit_stack, concurrent_precleaning),
+mark_stack, concurrent_precleaning),
 _yield(should_yield),
 _concurrent_precleaning(concurrent_precleaning),
 _freelistLock(NULL)
 {
 _ref_processor = rp;
 bool res = _mark_stack->push(obj);
 assert(res, "Should have space to push on empty stack");
 do {
 oop new_oop = _mark_stack->pop();
 assert(new_oop != NULL && new_oop->is_oop(), "Expected an oop");
-assert(new_oop->is_parsable(), "Found unparsable oop");
 assert(_bit_map->isMarked((HeapWord*)new_oop),
 "only grey objects on this stack");
 // iterate over the oops in this oop, marking and pushing
 // the ones in CMS heap (i.e. in _span).
 new_oop->oop_iterate(&_pushAndMarkClosure);
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_freelistLock);
 assert_lock_strong(_bit_map->lock());
 // relinquish the free_list_lock and bitMaplock()
-DEBUG_ONLY(RememberKlassesChecker mux(false);)
 _bit_map->lock()->unlock();
 _freelistLock->unlock();
 ConcurrentMarkSweepThread::desynchronize(true);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 _collector->stopTimer();
 // Par_MarkRefsIntoAndScanClosure: a parallel version of
 //                                 MarkRefsIntoAndScanClosure
 ///////////////////////////////////////////////////////////
 Par_MarkRefsIntoAndScanClosure::Par_MarkRefsIntoAndScanClosure(
 CMSCollector* collector, MemRegion span, ReferenceProcessor* rp,
-CMSBitMap* bit_map, OopTaskQueue* work_queue, CMSMarkStack*  revisit_stack):
+CMSBitMap* bit_map, OopTaskQueue* work_queue):
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue),
 _low_water_mark(MIN2((uint)(work_queue->max_elems()/4),
 (uint)(CMSWorkQueueDrainThreshold * ParallelGCThreads))),
-_par_pushAndMarkClosure(collector, span, rp, bit_map, work_queue,
+_par_pushAndMarkClosure(collector, span, rp, bit_map, work_queue)
-revisit_stack)
 {
 _ref_processor = rp;
 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL");
 }
 return 0;
 }
 if (_bitMap->isMarked(addr)) {
 // it's marked; is it potentially uninitialized?
 if (p->klass_or_null() != NULL) {
-// If is_conc_safe is false, the object may be undergoing
-// change by the VM outside a safepoint.  Don't try to
-// scan it, but rather leave it for the remark phase.
-if (CMSPermGenPrecleaningEnabled &&
-(!p->is_conc_safe() || !p->is_parsable())) {
-// Signal precleaning to redirty the card since
-// the klass pointer is already installed.
-assert(size == 0, "Initial value");
-} else {
-assert(p->is_parsable(), "must be parsable.");
 // an initialized object; ignore mark word in verification below
 // since we are running concurrent with mutators
 assert(p->is_oop(true), "should be an oop");
 if (p->is_objArray()) {
 // objArrays are precisely marked; restrict scanning
 _bitMap->verifyNoOneBitsInRange(addr+2, addr+size-1);
 assert(_bitMap->isMarked(addr+size-1),
 "inconsistent Printezis mark");
 }
 #endif // DEBUG
-}
 } else {
 // an unitialized object
 assert(_bitMap->isMarked(addr+1), "missing Printezis mark?");
 HeapWord* nextOneAddr = _bitMap->getNextMarkedWordAddress(addr + 2);
 size = pointer_delta(nextOneAddr + 1, addr);
 // will dirty the card when the klass pointer is installed in the
 // object (signalling the completion of initialization).
 }
 } else {
 // Either a not yet marked object or an uninitialized object
-if (p->klass_or_null() == NULL || !p->is_parsable()) {
+if (p->klass_or_null() == NULL) {
 // An uninitialized object, skip to the next card, since
 // we may not be able to read its P-bits yet.
 assert(size == 0, "Initial value");
 } else {
 // An object not (yet) reached by marking: we merely need to
 void ScanMarkedObjectsAgainCarefullyClosure::do_yield_work() {
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_freelistLock);
 assert_lock_strong(_bitMap->lock());
-DEBUG_ONLY(RememberKlassesChecker mux(false);)
 // relinquish the free_list_lock and bitMaplock()
 _bitMap->lock()->unlock();
 _freelistLock->unlock();
 ConcurrentMarkSweepThread::desynchronize(true);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 HeapWord* addr = (HeapWord*)p;
 DEBUG_ONLY(_collector->verify_work_stacks_empty();)
 assert(!_span.contains(addr), "we are scanning the survivor spaces");
 assert(p->klass_or_null() != NULL, "object should be initializd");
-assert(p->is_parsable(), "must be parsable.");
 // an initialized object; ignore mark word in verification below
 // since we are running concurrent with mutators
 assert(p->is_oop(true), "should be an oop");
 // Note that we do not yield while we iterate over
 // the interior oops of p, pushing the relevant ones
 // good idea to abort immediately and complete the marking
 // from the grey objects at a later time.
 while (!_mark_stack->isEmpty()) {
 oop new_oop = _mark_stack->pop();
 assert(new_oop != NULL && new_oop->is_oop(), "Expected an oop");
-assert(new_oop->is_parsable(), "Found unparsable oop");
 assert(_bit_map->isMarked((HeapWord*)new_oop),
 "only grey objects on this stack");
 // iterate over the oops in this oop, marking and pushing
 // the ones in CMS heap (i.e. in _span).
 new_oop->oop_iterate(_scanning_closure);
 void SurvivorSpacePrecleanClosure::do_yield_work() {
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_bit_map->lock());
-DEBUG_ONLY(RememberKlassesChecker smx(false);)
 // Relinquish the bit map lock
 _bit_map->lock()->unlock();
 ConcurrentMarkSweepThread::desynchronize(true);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 _collector->stopTimer();
 }
 MarkFromRootsClosure::MarkFromRootsClosure(CMSCollector* collector,
 MemRegion span,
 CMSBitMap* bitMap, CMSMarkStack*  markStack,
-CMSMarkStack*  revisitStack,
 bool should_yield, bool verifying):
 _collector(collector),
 _span(span),
 _bitMap(bitMap),
 _mut(&collector->_modUnionTable),
 _markStack(markStack),
-_revisitStack(revisitStack),
 _yield(should_yield),
 _skipBits(0)
 {
 assert(_markStack->isEmpty(), "stack should be empty");
 _finger = _bitMap->startWord();
 if (_bitMap->isMarked(addr+1)) {
 // this is an allocated but not yet initialized object
 assert(_skipBits == 0, "tautology");
 _skipBits = 2;  // skip next two marked bits ("Printezis-marks")
 oop p = oop(addr);
-if (p->klass_or_null() == NULL || !p->is_parsable()) {
+if (p->klass_or_null() == NULL) {
 DEBUG_ONLY(if (!_verifying) {)
 // We re-dirty the cards on which this object lies and increase
 // the _threshold so that we'll come back to scan this object
 // during the preclean or remark phase. (CMSCleanOnEnter)
 if (CMSCleanOnEnter) {
 // do this unlock/lock or modify the MutexUnlocker class to
 // serve our purpose. XXX
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 assert_lock_strong(_bitMap->lock());
-DEBUG_ONLY(RememberKlassesChecker mux(false);)
 _bitMap->lock()->unlock();
 ConcurrentMarkSweepThread::desynchronize(true);
 ConcurrentMarkSweepThread::acknowledge_yield_request();
 _collector->stopTimer();
 GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
 _threshold = (HeapWord*)round_to(
 (intptr_t)_finger, CardTableModRefBS::card_size);
 MemRegion mr(old_threshold, _threshold);
 assert(!mr.is_empty(), "Control point invariant");
 assert(_span.contains(mr), "Should clear within span");
-// XXX When _finger crosses from old gen into perm gen
-// we may be doing unnecessary cleaning; do better in the
-// future by detecting that condition and clearing fewer
-// MUT/CT entries.
 _mut->clear_range(mr);
 }
 DEBUG_ONLY(})
 // Note: the finger doesn't advance while we drain
 // the stack below.
 PushOrMarkClosure pushOrMarkClosure(_collector,
 _span, _bitMap, _markStack,
-_revisitStack,
 _finger, this);
 bool res = _markStack->push(obj);
 assert(res, "Empty non-zero size stack should have space for single push");
 while (!_markStack->isEmpty()) {
 oop new_oop = _markStack->pop();
 Par_MarkFromRootsClosure::Par_MarkFromRootsClosure(CMSConcMarkingTask* task,
 CMSCollector* collector, MemRegion span,
 CMSBitMap* bit_map,
 OopTaskQueue* work_queue,
 CMSMarkStack*  overflow_stack,
-CMSMarkStack*  revisit_stack,
 bool should_yield):
 _collector(collector),
 _whole_span(collector->_span),
 _span(span),
 _bit_map(bit_map),
 _mut(&collector->_modUnionTable),
 _work_queue(work_queue),
 _overflow_stack(overflow_stack),
-_revisit_stack(revisit_stack),
 _yield(should_yield),
 _skip_bits(0),
 _task(task)
 {
 assert(_work_queue->size() == 0, "work_queue should be empty");
 if (_bit_map->isMarked(addr+1)) {
 // this is an allocated object that might not yet be initialized
 assert(_skip_bits == 0, "tautology");
 _skip_bits = 2;  // skip next two marked bits ("Printezis-marks")
 oop p = oop(addr);
-if (p->klass_or_null() == NULL || !p->is_parsable()) {
+if (p->klass_or_null() == NULL) {
 // in the case of Clean-on-Enter optimization, redirty card
 // and avoid clearing card by increasing  the threshold.
 return true;
 }
 }
 _threshold = (HeapWord*)round_to(
 (intptr_t)_finger, CardTableModRefBS::card_size);
 MemRegion mr(old_threshold, _threshold);
 assert(!mr.is_empty(), "Control point invariant");
 assert(_span.contains(mr), "Should clear within span"); // _whole_span ??
-// XXX When _finger crosses from old gen into perm gen
-// we may be doing unnecessary cleaning; do better in the
-// future by detecting that condition and clearing fewer
-// MUT/CT entries.
 _mut->clear_range(mr);
 }
 // Note: the local finger doesn't advance while we drain
 // the stack below, but the global finger sure can and will.
 HeapWord** gfa = _task->global_finger_addr();
 Par_PushOrMarkClosure pushOrMarkClosure(_collector,
 _span, _bit_map,
 _work_queue,
 _overflow_stack,
-_revisit_stack,
 _finger,
 gfa, this);
 bool res = _work_queue->push(obj);   // overflow could occur here
 assert(res, "Will hold once we use workqueues");
 while (true) {
 PushAndMarkVerifyClosure::PushAndMarkVerifyClosure(
 CMSCollector* collector, MemRegion span,
 CMSBitMap* verification_bm, CMSBitMap* cms_bm,
 CMSMarkStack*  mark_stack):
-OopClosure(collector->ref_processor()),
+CMSOopClosure(collector->ref_processor()),
 _collector(collector),
 _span(span),
 _verification_bm(verification_bm),
 _cms_bm(cms_bm),
 _mark_stack(mark_stack)
 }
 PushOrMarkClosure::PushOrMarkClosure(CMSCollector* collector,
 MemRegion span,
 CMSBitMap* bitMap, CMSMarkStack*  markStack,
-CMSMarkStack*  revisitStack,
 HeapWord* finger, MarkFromRootsClosure* parent) :
-KlassRememberingOopClosure(collector, collector->ref_processor(), revisitStack),
+CMSOopClosure(collector->ref_processor()),
+_collector(collector),
 _span(span),
 _bitMap(bitMap),
 _markStack(markStack),
 _finger(finger),
 _parent(parent)
 Par_PushOrMarkClosure::Par_PushOrMarkClosure(CMSCollector* collector,
 MemRegion span,
 CMSBitMap* bit_map,
 OopTaskQueue* work_queue,
 CMSMarkStack*  overflow_stack,
-CMSMarkStack*  revisit_stack,
 HeapWord* finger,
 HeapWord** global_finger_addr,
 Par_MarkFromRootsClosure* parent) :
-Par_KlassRememberingOopClosure(collector,
+CMSOopClosure(collector->ref_processor()),
-collector->ref_processor(),
+_collector(collector),
-revisit_stack),
 _whole_span(collector->_span),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue),
 _overflow_stack(overflow_stack),
 // Remember the least grey address discarded
 HeapWord* ra = (HeapWord*)_overflow_stack->least_value(lost);
 _collector->lower_restart_addr(ra);
 _overflow_stack->reset();  // discard stack contents
 _overflow_stack->expand(); // expand the stack if possible
+}
+void CMKlassClosure::do_klass(Klass* k) {
+assert(_oop_closure != NULL, "Not initialized?");
+k->oops_do(_oop_closure);
 }
 void PushOrMarkClosure::do_oop(oop obj) {
 // Ignore mark word because we are running concurrent with mutators.
 assert(obj->is_oop_or_null(true), "expected an oop or NULL");
 }
 void Par_PushOrMarkClosure::do_oop(oop* p)       { Par_PushOrMarkClosure::do_oop_work(p); }
 void Par_PushOrMarkClosure::do_oop(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
-KlassRememberingOopClosure::KlassRememberingOopClosure(CMSCollector* collector,
-ReferenceProcessor* rp,
-CMSMarkStack* revisit_stack) :
-OopClosure(rp),
-_collector(collector),
-_revisit_stack(revisit_stack),
-_should_remember_klasses(collector->should_unload_classes()) {}
 PushAndMarkClosure::PushAndMarkClosure(CMSCollector* collector,
 MemRegion span,
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
 CMSBitMap* mod_union_table,
 CMSMarkStack*  mark_stack,
-CMSMarkStack*  revisit_stack,
 bool           concurrent_precleaning):
-KlassRememberingOopClosure(collector, rp, revisit_stack),
+CMSOopClosure(rp),
+_collector(collector),
 _span(span),
 _bit_map(bit_map),
 _mod_union_table(mod_union_table),
 _mark_stack(mark_stack),
 _concurrent_precleaning(concurrent_precleaning)
 Par_PushAndMarkClosure::Par_PushAndMarkClosure(CMSCollector* collector,
 MemRegion span,
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
-OopTaskQueue* work_queue,
+OopTaskQueue* work_queue):
-CMSMarkStack* revisit_stack):
+CMSOopClosure(rp),
-Par_KlassRememberingOopClosure(collector, rp, revisit_stack),
+_collector(collector),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue)
 {
 assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL");
 }
 void Par_PushAndMarkClosure::do_oop(oop* p)       { Par_PushAndMarkClosure::do_oop_work(p); }
 void Par_PushAndMarkClosure::do_oop(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
-void PushAndMarkClosure::remember_mdo(DataLayout* v) {
-// TBD
-}
-void Par_PushAndMarkClosure::remember_mdo(DataLayout* v) {
-// TBD
-}
 void CMSPrecleanRefsYieldClosure::do_yield_work() {
-DEBUG_ONLY(RememberKlassesChecker mux(false);)
 Mutex* bml = _collector->bitMapLock();
 assert_lock_strong(bml);
 assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
 "CMS thread should hold CMS token");
 size = pointer_delta(nextOneAddr + 1, addr);
 assert(size == CompactibleFreeListSpace::adjustObjectSize(size),
 "alignment problem");
 #ifdef DEBUG
-if (oop(addr)->klass_or_null() != NULL &&
+if (oop(addr)->klass_or_null() != NULL) {
-(   !_collector->should_unload_classes()
-|| (oop(addr)->is_parsable()) &&
-oop(addr)->is_conc_safe())) {
 // Ignore mark word because we are running concurrent with mutators
 assert(oop(addr)->is_oop(true), "live block should be an oop");
-// is_conc_safe is checked before performing this assertion
-// because an object that is not is_conc_safe may yet have
-// the return from size() correct.
 assert(size ==
 CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size()),
 "P-mark and computed size do not agree");
 }
 #endif
 } else {
 // This should be an initialized object that's alive.
-assert(oop(addr)->klass_or_null() != NULL &&
+assert(oop(addr)->klass_or_null() != NULL,
-(!_collector->should_unload_classes()
-|| oop(addr)->is_parsable()),
 "Should be an initialized object");
-// Note that there are objects used during class redefinition,
-// e.g. merge_cp in VM_RedefineClasses::merge_cp_and_rewrite(),
-// which are discarded with their is_conc_safe state still
-// false.  These object may be floating garbage so may be
-// seen here.  If they are floating garbage their size
-// should be attainable from their klass.  Do not that
-// is_conc_safe() is true for oop(addr).
 // Ignore mark word because we are running concurrent with mutators
 assert(oop(addr)->is_oop(true), "live block should be an oop");
 // Verify that the bit map has no bits marked between
 // addr and purported end of this block.
 size = CompactibleFreeListSpace::adjustObjectSize(oop(addr)->size());
 HeapWord* addr = (HeapWord*)obj;
 return addr != NULL &&
 (!_span.contains(addr) || _bit_map->isMarked(addr));
 }
 CMSKeepAliveClosure::CMSKeepAliveClosure( CMSCollector* collector,
 MemRegion span,
 CMSBitMap* bit_map, CMSMarkStack* mark_stack,
-CMSMarkStack* revisit_stack, bool cpc):
+bool cpc):
-KlassRememberingOopClosure(collector, NULL, revisit_stack),
+_collector(collector),
 _span(span),
 _bit_map(bit_map),
 _mark_stack(mark_stack),
 _concurrent_precleaning(cpc) {
 assert(!_span.is_empty(), "Empty span could spell trouble");
 }
 CMSInnerParMarkAndPushClosure::CMSInnerParMarkAndPushClosure(
 CMSCollector* collector,
 MemRegion span, CMSBitMap* bit_map,
-CMSMarkStack* revisit_stack,
 OopTaskQueue* work_queue):
-Par_KlassRememberingOopClosure(collector, NULL, revisit_stack),
+_collector(collector),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue) { }
 void CMSInnerParMarkAndPushClosure::do_oop(oop obj) {

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 6725:da91efe96a93