jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp

-:882004b9e7e1
+:2c6ef90f030a
 }
 return true;
 }
 if (MetaspaceGC::should_concurrent_collect()) {
 if (Verbose && PrintGCDetails) {
 gclog_or_tty->print("CMSCollector: collect for metadata allocation ");
 }
 return true;
 }
 return false;
 }
 void CMSCollector::set_did_compact(bool v) { _cmsGen->set_did_compact(v); }
 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
 SharedHeap::ScanningOption(roots_scanning_options()),
-&notOlder,
+should_unload_classes(),
-NULL,
+&notOlder,
-NULL); // SSS: Provide correct closure
+NULL,
+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());
-KlassToOopClosure 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
-SharedHeap::ScanningOption(roots_scanning_options()),
+true,   // activate StrongRootsScope
-&notOlder,
+SharedHeap::ScanningOption(roots_scanning_options()),
-NULL,
+should_unload_classes(),
-&klass_closure);
+&notOlder,
+NULL,
+&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 CMSCollector::setup_cms_unloading_and_verification_state() {
 const  bool should_verify =   VerifyBeforeGC || VerifyAfterGC || VerifyDuringGC
 || VerifyBeforeExit;
-const  int  rso           =   SharedHeap::SO_Strings | SharedHeap::SO_AllCodeCache;
+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);
 tsk.work(0);
 }
 gch->set_par_threads(0);
 } else {
 // The serial version.
-KlassToOopClosure 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
 SharedHeap::ScanningOption(roots_scanning_options()),
-&notOlder,
+should_unload_classes(),
-NULL,
+&notOlder,
-&klass_closure);
+NULL,
+&cld_closure);
 }
 }
 // Clear mod-union table; it will be dirtied in the prologue of
 // CMS generation per each younger generation collection.
 // ---------- scan from roots --------------
 _timer.start();
 GenCollectedHeap* gch = GenCollectedHeap::heap();
 Par_MarkRefsIntoClosure par_mri_cl(_collector->_span, &(_collector->_markBitMap));
-KlassToOopClosure 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
-SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
+gch->gen_process_roots(_collector->_cmsGen->level(),
-&par_mri_cl,
+false,     // yg was scanned above
-NULL,
+false,     // this is parallel code
-&klass_closure);
+SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
+_collector->should_unload_classes(),
+&par_mri_cl,
+NULL,
+&cld_closure);
 assert(_collector->should_unload_classes()
 || (_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) {
 }
 // ---------- 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
 SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
-&par_mrias_cl,
+_collector->should_unload_classes(),
-NULL,
+&par_mrias_cl,
-NULL);     // The dirty klasses will be handled below
+NULL,
+NULL);     // The dirty klasses will be handled below
 assert(_collector->should_unload_classes()
 || (_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) {
 }
 // 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
 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
-SharedHeap::ScanningOption(roots_scanning_options()),
+false, // use the local StrongRootsScope
-&mrias_cl,
+SharedHeap::ScanningOption(roots_scanning_options()),
-NULL,
+should_unload_classes(),
-NULL);  // The dirty klasses will be handled below
+&mrias_cl,
+NULL,
+NULL); // The dirty klasses will be handled below
 assert(should_unload_classes()
 || (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");
 }
 }
 // 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) {
 {
 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, _gc_tracer_cm->gc_id());
+}
-// 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

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp

src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp