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

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 c2844108a708
children	d86b226e331a

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 #include "memory/collectorPolicy.hpp"
 #include "memory/gcLocker.inline.hpp"
 #include "memory/genCollectedHeap.hpp"
 #include "memory/genMarkSweep.hpp"
 #include "memory/genOopClosures.inline.hpp"
-#include "memory/iterator.hpp"
+#include "memory/iterator.inline.hpp"
 #include "memory/padded.hpp"
 #include "memory/referencePolicy.hpp"
 #include "memory/resourceArea.hpp"
 #include "memory/tenuredGeneration.hpp"
 #include "oops/oop.inline.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "runtime/globals_extension.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/java.hpp"
+#include "runtime/orderAccess.inline.hpp"
 #include "runtime/vmThread.hpp"
 #include "services/memoryService.hpp"
 #include "services/runtimeService.hpp"
 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 assert(_eden_chunk_array != NULL || _eden_chunk_capacity == 0, "Error");
 // Support for parallelizing survivor space rescan
 if ((CMSParallelRemarkEnabled && CMSParallelSurvivorRemarkEnabled) || CMSParallelInitialMarkEnabled) {
 const size_t max_plab_samples =
-((DefNewGeneration*)_young_gen)->max_survivor_size()/MinTLABSize;
+((DefNewGeneration*)_young_gen)->max_survivor_size() / plab_sample_minimum_size();
 _survivor_plab_array  = NEW_C_HEAP_ARRAY(ChunkArray, ParallelGCThreads, mtGC);
 _survivor_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, 2*max_plab_samples, mtGC);
 _cursor               = NEW_C_HEAP_ARRAY(size_t, ParallelGCThreads, mtGC);
 if (_survivor_plab_array == NULL || _survivor_chunk_array == NULL
 _gc_counters = new CollectorCounters("CMS", 1);
 _completed_initialization = true;
 _inter_sweep_timer.start();  // start of time
 }
+size_t CMSCollector::plab_sample_minimum_size() {
+// The default value of MinTLABSize is 2k, but there is
+// no way to get the default value if the flag has been overridden.
+return MAX2(ThreadLocalAllocBuffer::min_size() * HeapWordSize, 2 * K);
+}
 const char* ConcurrentMarkSweepGeneration::name() const {
 return "concurrent mark-sweep generation";
 }
 void ConcurrentMarkSweepGeneration::update_counters() {
 if (UsePerfData) {
 _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("cms_time_since_begin=%3.7f", stats().cms_time_since_begin());
+gclog_or_tty->print_cr("cms_time_since_end=%3.7f", stats().cms_time_since_end());
 gclog_or_tty->print_cr("metadata initialized %d",
 MetaspaceGC::should_concurrent_collect());
 }
 // ------------------------------------------------------------------
 }
 return true;
 }
 if (MetaspaceGC::should_concurrent_collect()) {
+if (Verbose && PrintGCDetails) {
+gclog_or_tty->print("CMSCollector: collect for metadata allocation ");
+}
+return true;
+}
+// CMSTriggerInterval starts a CMS cycle if enough time has passed.
+if (CMSTriggerInterval >= 0) {
+if (CMSTriggerInterval == 0) {
+// Trigger always
+return true;
+}
+// Check the CMS time since begin (we do not check the stats validity
+// as we want to be able to trigger the first CMS cycle as well)
+if (stats().cms_time_since_begin() >= (CMSTriggerInterval / ((double) MILLIUNITS))) {
 if (Verbose && PrintGCDetails) {
-gclog_or_tty->print("CMSCollector: collect for metadata allocation ");
+if (stats().valid()) {
+gclog_or_tty->print_cr("CMSCollector: collect because of trigger interval (time since last begin %3.7f secs)",
+stats().cms_time_since_begin());
+} else {
+gclog_or_tty->print_cr("CMSCollector: collect because of trigger interval (first collection)");
+}
 }
 return true;
 }
+}
 return false;
 }
 void CMSCollector::set_did_compact(bool v) { _cmsGen->set_did_compact(v); }
 gc_timer->register_gc_start();
 SerialOldTracer* gc_tracer = GenMarkSweep::gc_tracer();
 gc_tracer->report_gc_start(gch->gc_cause(), gc_timer->gc_start());
-GCTraceTime t("CMS:MSC ", PrintGCDetails && Verbose, true, NULL);
+GCTraceTime t("CMS:MSC ", PrintGCDetails && Verbose, true, NULL, gc_tracer->gc_id());
 if (PrintGC && Verbose && !(GCCause::is_user_requested_gc(gch->gc_cause()))) {
 gclog_or_tty->print_cr("Compact ConcurrentMarkSweepGeneration after %d "
 "collections passed to foreground collector", _full_gcs_since_conc_gc);
 }
 assert(Thread::current()->is_VM_thread(), "A foreground collection"
 "may only be done by the VM Thread with the world stopped");
 assert(ConcurrentMarkSweepThread::vm_thread_has_cms_token(),
 "VM thread should have CMS token");
+// The gc id is created in register_foreground_gc_start if this collection is synchronous
+const GCId gc_id = _collectorState == InitialMarking ? GCId::peek() : _gc_tracer_cm->gc_id();
 NOT_PRODUCT(GCTraceTime t("CMS:MS (foreground) ", PrintGCDetails && Verbose,
-true, NULL);)
+true, NULL, gc_id);)
 if (UseAdaptiveSizePolicy) {
 size_policy()->ms_collection_begin();
 }
 COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact);
 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.
+// Get a clear set of claim bits for the 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(),
+gch->gen_process_roots(_cmsGen->level(),
 true,   // younger gens are roots
 true,   // activate StrongRootsScope
-false,  // not scavenging
+SharedHeap::ScanningOption(roots_scanning_options()),
-SharedHeap::ScanningOption(roots_scanning_options()),
+should_unload_classes(),
 &notOlder,
-true,   // walk code active on stacks
+NULL,
-NULL,
+NULL);  // SSS: Provide correct closure
-NULL); // SSS: Provide correct closure
 // Now mark from the roots
 MarkFromRootsClosure markFromRootsClosure(this, _span,
 verification_mark_bm(), verification_mark_stack(),
 false /* don't yield */, true /* verifying */);
 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.
+// Get a clear set of claim bits for the 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);
+CLDToOopClosure cld_closure(&notOlder, true);
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
-gch->gen_process_strong_roots(_cmsGen->level(),
-true,   // younger gens are roots
+gch->gen_process_roots(_cmsGen->level(),
-true,   // activate StrongRootsScope
+true,   // younger gens are roots
-false,  // not scavenging
+true,   // activate StrongRootsScope
 SharedHeap::ScanningOption(roots_scanning_options()),
-&notOlder,
+should_unload_classes(),
-true,   // walk code active on stacks
+&notOlder,
 NULL,
-&klass_closure);
+&cld_closure);
 // Now mark from the roots
 MarkFromRootsVerifyClosure markFromRootsClosure(this, _span,
 verification_mark_bm(), markBitMap(), verification_mark_stack());
 assert(_restart_addr == NULL, "Expected pre-condition");
 void
 ConcurrentMarkSweepGeneration::younger_refs_iterate(OopsInGenClosure* cl) {
 cl->set_generation(this);
 younger_refs_in_space_iterate(_cmsSpace, cl);
 cl->reset_generation();
-}
-void
-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(ExtendedOopClosure* cl) {
 if (freelistLock()->owned_by_self()) {
 }
 void CMSCollector::setup_cms_unloading_and_verification_state() {
 const  bool should_verify =   VerifyBeforeGC || VerifyAfterGC || VerifyDuringGC
 || VerifyBeforeExit;
-const  int  rso           =   SharedHeap::SO_Strings | SharedHeap::SO_CodeCache;
+const  int  rso           =   SharedHeap::SO_AllCodeCache;
 // We set the proper root for this CMS cycle here.
 if (should_unload_classes()) {   // Should unload classes this cycle
-remove_root_scanning_option(SharedHeap::SO_AllClasses);
-add_root_scanning_option(SharedHeap::SO_SystemClasses);
 remove_root_scanning_option(rso);  // Shrink the root set appropriately
 set_verifying(should_verify);    // Set verification state for this cycle
 return;                            // Nothing else needs to be done at this time
 }
 // Not unloading classes this cycle
 assert(!should_unload_classes(), "Inconsitency!");
-remove_root_scanning_option(SharedHeap::SO_SystemClasses);
-add_root_scanning_option(SharedHeap::SO_AllClasses);
 if ((!verifying() || unloaded_classes_last_cycle()) && should_verify) {
 // Include symbols, strings and code cache elements to prevent their resurrection.
 add_root_scanning_option(rso);
 set_verifying(true);
 // phases.
 class CMSPhaseAccounting: public StackObj {
 public:
 CMSPhaseAccounting(CMSCollector *collector,
 const char *phase,
+const GCId gc_id,
 bool print_cr = true);
 ~CMSPhaseAccounting();
 private:
 CMSCollector *_collector;
 const char *_phase;
 elapsedTimer _wallclock;
 bool _print_cr;
+const GCId _gc_id;
 public:
 // Not MT-safe; so do not pass around these StackObj's
 // where they may be accessed by other threads.
 jlong wallclock_millis() {
 }
 };
 CMSPhaseAccounting::CMSPhaseAccounting(CMSCollector *collector,
 const char *phase,
+const GCId gc_id,
 bool print_cr) :
-_collector(collector), _phase(phase), _print_cr(print_cr) {
+_collector(collector), _phase(phase), _print_cr(print_cr), _gc_id(gc_id) {
 if (PrintCMSStatistics != 0) {
 _collector->resetYields();
 }
 if (PrintGCDetails) {
-gclog_or_tty->date_stamp(PrintGCDateStamps);
+gclog_or_tty->gclog_stamp(_gc_id);
-gclog_or_tty->stamp(PrintGCTimeStamps);
 gclog_or_tty->print_cr("[%s-concurrent-%s-start]",
 _collector->cmsGen()->short_name(), _phase);
 }
 _collector->resetTimer();
 _wallclock.start();
 CMSPhaseAccounting::~CMSPhaseAccounting() {
 assert(_wallclock.is_active(), "Wall clock should not have stopped");
 _collector->stopTimer();
 _wallclock.stop();
 if (PrintGCDetails) {
-gclog_or_tty->date_stamp(PrintGCDateStamps);
+gclog_or_tty->gclog_stamp(_gc_id);
-gclog_or_tty->stamp(PrintGCTimeStamps);
 gclog_or_tty->print("[%s-concurrent-%s: %3.3f/%3.3f secs]",
 _collector->cmsGen()->short_name(),
 _phase, _collector->timerValue(), _wallclock.seconds());
 if (_print_cr) {
 gclog_or_tty->cr();
 // Setup the verification and class unloading state for this
 // CMS collection cycle.
 setup_cms_unloading_and_verification_state();
 NOT_PRODUCT(GCTraceTime t("\ncheckpointRootsInitialWork",
-PrintGCDetails && Verbose, true, _gc_timer_cm);)
+PrintGCDetails && Verbose, true, _gc_timer_cm, _gc_tracer_cm->gc_id());)
 if (UseAdaptiveSizePolicy) {
 size_policy()->checkpoint_roots_initial_begin();
 }
 // Reset all the PLAB chunk arrays if necessary.
 }
 ResourceMark rm;
 HandleMark  hm;
-FalseClosure falseClosure;
-// In the case of a synchronous collection, we will elide the
-// remark step, so it's important to catch all the nmethod oops
-// in this step.
-// The final 'true' flag to gen_process_strong_roots will ensure this.
-// If 'async' is true, we can relax the nmethod tracing.
 MarkRefsIntoClosure notOlder(_span, &_markBitMap);
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 verify_work_stacks_empty();
 verify_overflow_empty();
 tsk.work(0);
 }
 gch->set_par_threads(0);
 } else {
 // The serial version.
-CMKlassClosure klass_closure(&notOlder);
+CLDToOopClosure cld_closure(&notOlder, true);
 gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
-gch->gen_process_strong_roots(_cmsGen->level(),
+gch->gen_process_roots(_cmsGen->level(),
 true,   // younger gens are roots
 true,   // activate StrongRootsScope
-false,  // not scavenging
+SharedHeap::ScanningOption(roots_scanning_options()),
-SharedHeap::ScanningOption(roots_scanning_options()),
+should_unload_classes(),
 &notOlder,
-true,   // walk all of code cache if (so & SO_CodeCache)
+NULL,
-NULL,
+&cld_closure);
-&klass_closure);
 }
 }
 // Clear mod-union table; it will be dirtied in the prologue of
 // CMS generation per each younger generation collection.
 // refs in this generation concurrent (but interleaved) with
 // weak ref discovery by a younger generation collector.
 CMSTokenSyncWithLocks ts(true, bitMapLock());
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-CMSPhaseAccounting pa(this, "mark", !PrintGCDetails);
+CMSPhaseAccounting pa(this, "mark", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 res = markFromRootsWork(asynch);
 if (res) {
 _collectorState = Precleaning;
 } else { // We failed and a foreground collection wants to take over
 assert(_foregroundGCIsActive, "internal state inconsistency");
 // have been bumped up by the thread that claimed the last
 // task.
 pst->all_tasks_completed();
 }
-class Par_ConcMarkingClosure: public CMSOopClosure {
+class Par_ConcMarkingClosure: public MetadataAwareOopClosure {
 private:
 CMSCollector* _collector;
 CMSConcMarkingTask* _task;
 MemRegion     _span;
 CMSBitMap*    _bit_map;
 protected:
 DO_OOP_WORK_DEFN
 public:
 Par_ConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue,
 CMSBitMap* bit_map, CMSMarkStack* overflow_stack):
-CMSOopClosure(collector->ref_processor()),
+MetadataAwareOopClosure(collector->ref_processor()),
 _collector(collector),
 _task(task),
 _span(collector->_span),
 _work_queue(work_queue),
 _bit_map(bit_map),
 _start_sampling = true;
 } else {
 _start_sampling = false;
 }
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-CMSPhaseAccounting pa(this, "preclean", !PrintGCDetails);
+CMSPhaseAccounting pa(this, "preclean", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 preclean_work(CMSPrecleanRefLists1, CMSPrecleanSurvivors1);
 }
 CMSTokenSync x(true); // is cms thread
 if (CMSPrecleaningEnabled) {
 sample_eden();
 // schedule the pause as described avove. By choosing
 // CMSScheduleRemarkEdenSizeThreshold >= max eden size
 // we will never do an actual abortable preclean cycle.
 if (get_eden_used() > CMSScheduleRemarkEdenSizeThreshold) {
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-CMSPhaseAccounting pa(this, "abortable-preclean", !PrintGCDetails);
+CMSPhaseAccounting pa(this, "abortable-preclean", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 // We need more smarts in the abortable preclean
 // loop below to deal with cases where allocation
 // in young gen is very very slow, and our precleaning
 // is running a losing race against a horde of
 // mutators intent on flooding us with CMS updates
 // tweaking for better performance and some restructuring
 // for cleaner interfaces.
 GCTimer *gc_timer = NULL; // Currently not tracing concurrent phases
 rp->preclean_discovered_references(
 rp->is_alive_non_header(), &keep_alive, &complete_trace, &yield_cl,
-gc_timer);
+gc_timer, _gc_tracer_cm->gc_id());
 }
 if (clean_survivor) {  // preclean the active survivor space(s)
 assert(_young_gen->kind() == Generation::DefNew ||
 _young_gen->kind() == Generation::ParNew ||
 verify_overflow_empty();
 return cumNumDirtyCards;
 }
 class PrecleanKlassClosure : public KlassClosure {
-CMKlassClosure _cm_klass_closure;
+KlassToOopClosure _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();
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 // Temporarily set flag to false, GCH->do_collection will
 // expect it to be false and set to true
 FlagSetting fl(gch->_is_gc_active, false);
 NOT_PRODUCT(GCTraceTime t("Scavenge-Before-Remark",
-PrintGCDetails && Verbose, true, _gc_timer_cm);)
+PrintGCDetails && Verbose, true, _gc_timer_cm, _gc_tracer_cm->gc_id());)
 int level = _cmsGen->level() - 1;
 if (level >= 0) {
 gch->do_collection(true,        // full (i.e. force, see below)
 false,       // !clear_all_soft_refs
 0,           // size
 }
 void CMSCollector::checkpointRootsFinalWork(bool asynch,
 bool clear_all_soft_refs, bool init_mark_was_synchronous) {
-NOT_PRODUCT(GCTraceTime tr("checkpointRootsFinalWork", PrintGCDetails, false, _gc_timer_cm);)
+NOT_PRODUCT(GCTraceTime tr("checkpointRootsFinalWork", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());)
 assert(haveFreelistLocks(), "must have free list locks");
 assert_lock_strong(bitMapLock());
 if (UseAdaptiveSizePolicy) {
 // are detected via the mod union table which is the set of all cards
 // dirtied since the first checkpoint in this GC cycle and prior to
 // the most recent young generation GC, minus those cleaned up by the
 // concurrent precleaning.
 if (CMSParallelRemarkEnabled && CollectedHeap::use_parallel_gc_threads()) {
-GCTraceTime t("Rescan (parallel) ", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("Rescan (parallel) ", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 do_remark_parallel();
 } else {
 GCTraceTime t("Rescan (non-parallel) ", PrintGCDetails, false,
-_gc_timer_cm);
+_gc_timer_cm, _gc_tracer_cm->gc_id());
 do_remark_non_parallel();
 }
 }
 } else {
 assert(!asynch, "Can't have init_mark_was_synchronous in asynch mode");
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
 {
-NOT_PRODUCT(GCTraceTime ts("refProcessingWork", PrintGCDetails, false, _gc_timer_cm);)
+NOT_PRODUCT(GCTraceTime ts("refProcessingWork", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());)
 refProcessingWork(asynch, clear_all_soft_refs);
 }
 verify_work_stacks_empty();
 verify_overflow_empty();
 // ---------- scan from roots --------------
 _timer.start();
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 Par_MarkRefsIntoClosure par_mri_cl(_collector->_span, &(_collector->_markBitMap));
-CMKlassClosure klass_closure(&par_mri_cl);
 // ---------- young gen roots --------------
 {
 work_on_young_gen_roots(worker_id, &par_mri_cl);
 _timer.stop();
 }
 // ---------- remaining roots --------------
 _timer.reset();
 _timer.start();
-gch->gen_process_strong_roots(_collector->_cmsGen->level(),
-false,     // yg was scanned above
+CLDToOopClosure cld_closure(&par_mri_cl, true);
-false,     // this is parallel code
-false,     // not scavenging
+gch->gen_process_roots(_collector->_cmsGen->level(),
-SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
+false,     // yg was scanned above
-&par_mri_cl,
+false,     // this is parallel code
-true,   // walk all of code cache if (so & SO_CodeCache)
+SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
-NULL,
+_collector->should_unload_classes(),
-&klass_closure);
+&par_mri_cl,
+NULL,
+&cld_closure);
 assert(_collector->should_unload_classes()
-|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_CodeCache),
+|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_AllCodeCache),
 "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 initial mark scan work in %dth thread: %3.3f sec",
 // ... work stealing for the above
 void do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, int* seed);
 };
 class RemarkKlassClosure : public KlassClosure {
-CMKlassClosure _cm_klass_closure;
+KlassToOopClosure _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()) {
 }
 // ---------- remaining roots --------------
 _timer.reset();
 _timer.start();
-gch->gen_process_strong_roots(_collector->_cmsGen->level(),
+gch->gen_process_roots(_collector->_cmsGen->level(),
 false,     // yg was scanned above
 false,     // this is parallel code
-false,     // not scavenging
+SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
-SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
+_collector->should_unload_classes(),
 &par_mrias_cl,
-true,   // walk all of code cache if (so & SO_CodeCache)
+NULL,
-NULL,
+NULL);     // The dirty klasses will be handled below
-NULL);     // The dirty klasses will be handled below
 assert(_collector->should_unload_classes()
-|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_CodeCache),
+|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_AllCodeCache),
 "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",
 }
 // 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,
+// code, or when the young collector processes the roots. Hence,
 // we don't have to revisit the _handles block during the remark phase.
 // ---------- rescan dirty cards ------------
 _timer.reset();
 _timer.start();
 CMSParRemarkTask tsk(this,
 cms_space,
 n_workers, workers, task_queues());
-// Set up for parallel process_strong_roots work.
+// Set up for parallel process_roots work.
 gch->set_par_threads(n_workers);
 // We won't be iterating over the cards in the card table updating
 // the younger_gen cards, so we shouldn't call the following else
 // the verification code as well as subsequent younger_refs_iterate
 // code would get confused. XXX
 // gch->rem_set()->prepare_for_younger_refs_iterate(true); // parallel
 // The young gen rescan work will not be done as part of
-// process_strong_roots (which currently doesn't knw how to
+// process_roots (which currently doesn't know how to
 // parallelize such a scan), but rather will be broken up into
 // a set of parallel tasks (via the sampling that the [abortable]
 // preclean phase did of EdenSpace, plus the [two] tasks of
 // scanning the [two] survivor spaces. Further fine-grain
 // parallelization of the scanning of the survivor spaces
 MarkFromDirtyCardsClosure
 markFromDirtyCardsClosure(this, _span,
 NULL,  // space is set further below
 &_markBitMap, &_markStack, &mrias_cl);
 {
-GCTraceTime t("grey object rescan", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("grey object rescan", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 // Iterate over the dirty cards, setting the corresponding bits in the
 // mod union table.
 {
 ModUnionClosure modUnionClosure(&_modUnionTable);
 _ct->ct_bs()->dirty_card_iterate(
 GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
 HandleMark hm;  // Discard invalid handles created during verification
 Universe::verify();
 }
 {
-GCTraceTime t("root rescan", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("root rescan", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 verify_work_stacks_empty();
 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
+gch->gen_process_roots(_cmsGen->level(),
-false, // use the local StrongRootsScope
+true,  // younger gens as roots
-false, // not scavenging
+false, // use the local StrongRootsScope
 SharedHeap::ScanningOption(roots_scanning_options()),
-&mrias_cl,
+should_unload_classes(),
-true,   // walk code active on stacks
+&mrias_cl,
 NULL,
-NULL);  // The dirty klasses will be handled below
+NULL); // The dirty klasses will be handled below
 assert(should_unload_classes()
-|| (roots_scanning_options() & SharedHeap::SO_CodeCache),
+|| (roots_scanning_options() & SharedHeap::SO_AllCodeCache),
 "if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops");
 }
 {
-GCTraceTime t("visit unhandled CLDs", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("visit unhandled CLDs", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 verify_work_stacks_empty();
 // Scan all class loader data objects that might have been introduced
 // during concurrent marking.
 verify_work_stacks_empty();
 }
 {
-GCTraceTime t("dirty klass scan", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("dirty klass scan", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 verify_work_stacks_empty();
 RemarkKlassClosure remark_klass_closure(&mrias_cl);
 ClassLoaderDataGraph::classes_do(&remark_klass_closure);
 }
 // 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,
+// code, or when the young collector processes the 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) {
 virtual void work(uint worker_id);
 };
 void CMSRefProcTaskProxy::work(uint worker_id) {
+ResourceMark rm;
+HandleMark hm;
 assert(_collector->_span.equals(_span), "Inconsistency in _span");
 CMSParKeepAliveClosure par_keep_alive(_collector, _span,
 _mark_bit_map,
 work_queue(worker_id));
 CMSParDrainMarkingStackClosure par_drain_stack(_collector, _span,
 &_markStack, false /* !preclean */);
 CMSDrainMarkingStackClosure cmsDrainMarkingStackClosure(this,
 _span, &_markBitMap, &_markStack,
 &cmsKeepAliveClosure, false /* !preclean */);
 {
-GCTraceTime t("weak refs processing", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("weak refs processing", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 ReferenceProcessorStats stats;
 if (rp->processing_is_mt()) {
 // Set the degree of MT here.  If the discovery is done MT, there
 // may have been a different number of threads doing the discovery
 CMSRefProcTaskExecutor task_executor(*this);
 stats = rp->process_discovered_references(&_is_alive_closure,
 &cmsKeepAliveClosure,
 &cmsDrainMarkingStackClosure,
 &task_executor,
-_gc_timer_cm);
+_gc_timer_cm,
+_gc_tracer_cm->gc_id());
 } else {
 stats = rp->process_discovered_references(&_is_alive_closure,
 &cmsKeepAliveClosure,
 &cmsDrainMarkingStackClosure,
 NULL,
-_gc_timer_cm);
+_gc_timer_cm,
+_gc_tracer_cm->gc_id());
 }
 _gc_tracer_cm->report_gc_reference_stats(stats);
 }
 // This is the point where the entire marking should have completed.
 verify_work_stacks_empty();
 if (should_unload_classes()) {
 {
-GCTraceTime t("class unloading", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("class unloading", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 // Unload classes and purge the SystemDictionary.
 bool purged_class = SystemDictionary::do_unloading(&_is_alive_closure);
 // Unload nmethods.
 // Prune dead klasses from subklass/sibling/implementor lists.
 Klass::clean_weak_klass_links(&_is_alive_closure);
 }
 {
-GCTraceTime t("scrub symbol table", PrintGCDetails, false, _gc_timer_cm);
+GCTraceTime t("scrub symbol table", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
 // Clean up unreferenced symbols in symbol table.
 SymbolTable::unlink();
 }
-}
+{
-// CMS doesn't use the StringTable as hard roots when class unloading is turned off.
+GCTraceTime t("scrub string table", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
-// Need to check if we really scanned the StringTable.
+// Delete entries for dead interned strings.
-if ((roots_scanning_options() & SharedHeap::SO_Strings) == 0) {
+StringTable::unlink(&_is_alive_closure);
-GCTraceTime t("scrub string table", PrintGCDetails, false, _gc_timer_cm);
+}
-// Delete entries for dead interned strings.
+}
-StringTable::unlink(&_is_alive_closure);
-}
 // Restore any preserved marks as a result of mark stack or
 // work queue overflow
 restore_preserved_marks_if_any();  // done single-threaded for now
 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);
+CMSPhaseAccounting pa(this, "sweep", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 // First sweep the old gen
 {
 CMSTokenSyncWithLocks ts(true, _cmsGen->freelistLock(),
 bitMapLock());
 sweepWork(_cmsGen, asynch);
 }
 // Clear the mark bitmap (no grey objects to start with)
 // for the next cycle.
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-CMSPhaseAccounting cmspa(this, "reset", !PrintGCDetails);
+CMSPhaseAccounting cmspa(this, "reset", _gc_tracer_cm->gc_id(), !PrintGCDetails);
 HeapWord* curAddr = _markBitMap.startWord();
 while (curAddr < _markBitMap.endWord()) {
 size_t remaining  = pointer_delta(_markBitMap.endWord(), curAddr);
 MemRegion chunk(curAddr, MIN2(CMSBitMapYieldQuantum, remaining));
 }
 void CMSCollector::do_CMS_operation(CMS_op_type op, GCCause::Cause gc_cause) {
 gclog_or_tty->date_stamp(PrintGC && PrintGCDateStamps);
 TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty);
-GCTraceTime t(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, NULL);
+GCTraceTime t(GCCauseString("GC", gc_cause), PrintGC, !PrintGCDetails, NULL, _gc_tracer_cm->gc_id());
 TraceCollectorStats tcs(counters());
 switch (op) {
 case CMS_op_checkpointRootsInitial: {
 SvcGCMarker sgcm(SvcGCMarker::OTHER);
 PushAndMarkVerifyClosure::PushAndMarkVerifyClosure(
 CMSCollector* collector, MemRegion span,
 CMSBitMap* verification_bm, CMSBitMap* cms_bm,
 CMSMarkStack*  mark_stack):
-CMSOopClosure(collector->ref_processor()),
+MetadataAwareOopClosure(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,
 HeapWord* finger, MarkFromRootsClosure* parent) :
-CMSOopClosure(collector->ref_processor()),
+MetadataAwareOopClosure(collector->ref_processor()),
 _collector(collector),
 _span(span),
 _bitMap(bitMap),
 _markStack(markStack),
 _finger(finger),
 OopTaskQueue* work_queue,
 CMSMarkStack*  overflow_stack,
 HeapWord* finger,
 HeapWord** global_finger_addr,
 Par_MarkFromRootsClosure* parent) :
-CMSOopClosure(collector->ref_processor()),
+MetadataAwareOopClosure(collector->ref_processor()),
 _collector(collector),
 _whole_span(collector->_span),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue),
 // 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");
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
 CMSBitMap* mod_union_table,
 CMSMarkStack*  mark_stack,
 bool           concurrent_precleaning):
-CMSOopClosure(rp),
+MetadataAwareOopClosure(rp),
 _collector(collector),
 _span(span),
 _bit_map(bit_map),
 _mod_union_table(mod_union_table),
 _mark_stack(mark_stack),
 Par_PushAndMarkClosure::Par_PushAndMarkClosure(CMSCollector* collector,
 MemRegion span,
 ReferenceProcessor* rp,
 CMSBitMap* bit_map,
 OopTaskQueue* work_queue):
-CMSOopClosure(rp),
+MetadataAwareOopClosure(rp),
 _collector(collector),
 _span(span),
 _bit_map(bit_map),
 _work_queue(work_queue)
 {

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp @ 20804:7848fc12602b