# HG changeset patch # User mgerdin # Date 1389714033 -3600 # Node ID 870aedf4ba4f05d0d4621ecf5722f859ff82a585 # Parent 7ab52431bc9f22dd7c579443239e8c8a0732c6f3 8032379: Remove the is_scavenging flag to process_strong_roots Summary: Refactor the strong root processing to avoid using a boolean in addition to the ScanOption enum. Reviewed-by: stefank, tschatzl, ehelin, jmasa diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Tue Jan 14 16:40:33 2014 +0100 @@ -3033,7 +3033,6 @@ gch->gen_process_strong_roots(_cmsGen->level(), true, // younger gens are roots true, // activate StrongRootsScope - false, // not scavenging SharedHeap::ScanningOption(roots_scanning_options()), ¬Older, true, // walk code active on stacks @@ -3101,7 +3100,6 @@ gch->gen_process_strong_roots(_cmsGen->level(), true, // younger gens are roots true, // activate StrongRootsScope - false, // not scavenging SharedHeap::ScanningOption(roots_scanning_options()), ¬Older, true, // walk code active on stacks @@ -3303,7 +3301,7 @@ 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_Strings | SharedHeap::SO_AllCodeCache; // We set the proper root for this CMS cycle here. if (should_unload_classes()) { // Should unload classes this cycle @@ -3738,10 +3736,9 @@ gch->gen_process_strong_roots(_cmsGen->level(), true, // younger gens are roots true, // activate StrongRootsScope - false, // not scavenging SharedHeap::ScanningOption(roots_scanning_options()), ¬Older, - true, // walk all of code cache if (so & SO_CodeCache) + true, // walk all of code cache if (so & SO_AllCodeCache) NULL, &klass_closure); } @@ -5238,14 +5235,13 @@ gch->gen_process_strong_roots(_collector->_cmsGen->level(), false, // yg was scanned above false, // this is parallel code - false, // not scavenging SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()), &par_mri_cl, - true, // walk all of code cache if (so & SO_CodeCache) + true, // walk all of code cache if (so & SO_AllCodeCache) NULL, &klass_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) { @@ -5375,14 +5371,13 @@ gch->gen_process_strong_roots(_collector->_cmsGen->level(), false, // yg was scanned above false, // this is parallel code - false, // not scavenging SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()), &par_mrias_cl, - true, // walk all of code cache if (so & SO_CodeCache) + true, // walk all of code cache if (so & SO_AllCodeCache) NULL, 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) { @@ -5966,7 +5961,6 @@ gch->gen_process_strong_roots(_cmsGen->level(), true, // younger gens as roots false, // use the local StrongRootsScope - false, // not scavenging SharedHeap::ScanningOption(roots_scanning_options()), &mrias_cl, true, // walk code active on stacks @@ -5974,7 +5968,7 @@ 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"); } diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp --- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Tue Jan 14 16:40:33 2014 +0100 @@ -3392,14 +3392,12 @@ // We apply the relevant closures to all the oops in the // system dictionary, the string table and the code cache. - const int so = SO_AllClasses | SO_Strings | SO_CodeCache; + const int so = SO_AllClasses | SO_Strings | SO_AllCodeCache; // Need cleared claim bits for the strong roots processing ClassLoaderDataGraph::clear_claimed_marks(); process_strong_roots(true, // activate StrongRootsScope - false, // we set "is scavenging" to false, - // so we don't reset the dirty cards. ScanningOption(so), // roots scanning options &rootsCl, &blobsCl, @@ -5106,13 +5104,13 @@ BufferingOopClosure buf_scan_non_heap_roots(scan_non_heap_roots); - assert(so & SO_CodeCache || scan_rs != NULL, "must scan code roots somehow"); + assert(so & SO_AllCodeCache || scan_rs != NULL, "must scan code roots somehow"); // Walk the code cache/strong code roots w/o buffering, because StarTask // cannot handle unaligned oop locations. CodeBlobToOopClosure eager_scan_code_roots(scan_non_heap_roots, true /* do_marking */); process_strong_roots(false, // no scoping; this is parallel code - is_scavenging, so, + so, &buf_scan_non_heap_roots, &eager_scan_code_roots, scan_klasses @@ -5160,7 +5158,7 @@ // the collection set. // Note all threads participate in this set of root tasks. double mark_strong_code_roots_ms = 0.0; - if (g1_policy()->during_initial_mark_pause() && !(so & SO_CodeCache)) { + if (g1_policy()->during_initial_mark_pause() && !(so & SO_AllCodeCache)) { double mark_strong_roots_start = os::elapsedTime(); mark_strong_code_roots(worker_i); mark_strong_code_roots_ms = (os::elapsedTime() - mark_strong_roots_start) * 1000.0; diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/gc_implementation/g1/g1MarkSweep.cpp --- a/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Tue Jan 14 16:40:33 2014 +0100 @@ -131,7 +131,6 @@ ClassLoaderDataGraph::clear_claimed_marks(); sh->process_strong_roots(true, // activate StrongRootsScope - false, // not scavenging. SharedHeap::SO_SystemClasses, &GenMarkSweep::follow_root_closure, &GenMarkSweep::follow_code_root_closure, @@ -308,7 +307,6 @@ ClassLoaderDataGraph::clear_claimed_marks(); sh->process_strong_roots(true, // activate StrongRootsScope - false, // not scavenging. SharedHeap::SO_AllClasses, &GenMarkSweep::adjust_pointer_closure, NULL, // do not touch code cache here diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/gc_implementation/parNew/parNewGeneration.cpp --- a/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Tue Jan 14 16:40:33 2014 +0100 @@ -612,14 +612,13 @@ KlassScanClosure klass_scan_closure(&par_scan_state.to_space_root_closure(), gch->rem_set()->klass_rem_set()); - int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_CodeCache; + int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_ScavengeCodeCache; par_scan_state.start_strong_roots(); gch->gen_process_strong_roots(_gen->level(), true, // Process younger gens, if any, // as strong roots. false, // no scope; this is parallel code - true, // is scavenging SharedHeap::ScanningOption(so), &par_scan_state.to_space_root_closure(), true, // walk *all* scavengable nmethods diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/memory/defNewGeneration.cpp --- a/src/share/vm/memory/defNewGeneration.cpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/memory/defNewGeneration.cpp Tue Jan 14 16:40:33 2014 +0100 @@ -618,13 +618,12 @@ assert(gch->no_allocs_since_save_marks(0), "save marks have not been newly set."); - int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_CodeCache; + int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_ScavengeCodeCache; gch->gen_process_strong_roots(_level, true, // Process younger gens, if any, // as strong roots. true, // activate StrongRootsScope - true, // is scavenging SharedHeap::ScanningOption(so), &fsc_with_no_gc_barrier, true, // walk *all* scavengable nmethods diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/memory/genCollectedHeap.cpp --- a/src/share/vm/memory/genCollectedHeap.cpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/memory/genCollectedHeap.cpp Tue Jan 14 16:40:33 2014 +0100 @@ -592,7 +592,6 @@ gen_process_strong_roots(int level, bool younger_gens_as_roots, bool activate_scope, - bool is_scavenging, SharedHeap::ScanningOption so, OopsInGenClosure* not_older_gens, bool do_code_roots, @@ -601,12 +600,12 @@ // General strong roots. if (!do_code_roots) { - SharedHeap::process_strong_roots(activate_scope, is_scavenging, so, + SharedHeap::process_strong_roots(activate_scope, so, not_older_gens, NULL, klass_closure); } else { bool do_code_marking = (activate_scope || nmethod::oops_do_marking_is_active()); CodeBlobToOopClosure code_roots(not_older_gens, /*do_marking=*/ do_code_marking); - SharedHeap::process_strong_roots(activate_scope, is_scavenging, so, + SharedHeap::process_strong_roots(activate_scope, so, not_older_gens, &code_roots, klass_closure); } diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/memory/genCollectedHeap.hpp --- a/src/share/vm/memory/genCollectedHeap.hpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/memory/genCollectedHeap.hpp Tue Jan 14 16:40:33 2014 +0100 @@ -411,7 +411,6 @@ // The remaining arguments are in an order // consistent with SharedHeap::process_strong_roots: bool activate_scope, - bool is_scavenging, SharedHeap::ScanningOption so, OopsInGenClosure* not_older_gens, bool do_code_roots, diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/memory/genMarkSweep.cpp --- a/src/share/vm/memory/genMarkSweep.cpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/memory/genMarkSweep.cpp Tue Jan 14 16:40:33 2014 +0100 @@ -210,7 +210,6 @@ gch->gen_process_strong_roots(level, false, // Younger gens are not roots. true, // activate StrongRootsScope - false, // not scavenging SharedHeap::SO_SystemClasses, &follow_root_closure, true, // walk code active on stacks @@ -296,7 +295,6 @@ gch->gen_process_strong_roots(level, false, // Younger gens are not roots. true, // activate StrongRootsScope - false, // not scavenging SharedHeap::SO_AllClasses, &adjust_pointer_closure, false, // do not walk code diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/memory/sharedHeap.cpp --- a/src/share/vm/memory/sharedHeap.cpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/memory/sharedHeap.cpp Tue Jan 14 16:40:33 2014 +0100 @@ -137,7 +137,6 @@ } void SharedHeap::process_strong_roots(bool activate_scope, - bool is_scavenging, ScanningOption so, OopClosure* roots, CodeBlobClosure* code_roots, @@ -157,9 +156,11 @@ if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do)) JNIHandles::oops_do(roots); + CLDToOopClosure roots_from_clds(roots); + // If we limit class scanning to SO_SystemClasses we need to apply a CLD closure to + // CLDs which are strongly reachable from the thread stacks. + CLDToOopClosure* roots_from_clds_p = ((so & SO_SystemClasses) ? &roots_from_clds : NULL); // All threads execute this; the individual threads are task groups. - CLDToOopClosure roots_from_clds(roots); - CLDToOopClosure* roots_from_clds_p = (is_scavenging ? NULL : &roots_from_clds); if (CollectedHeap::use_parallel_gc_threads()) { Threads::possibly_parallel_oops_do(roots, roots_from_clds_p, code_roots); } else { @@ -187,9 +188,9 @@ if (!_process_strong_tasks->is_task_claimed(SH_PS_ClassLoaderDataGraph_oops_do)) { if (so & SO_AllClasses) { - ClassLoaderDataGraph::oops_do(roots, klass_closure, !is_scavenging); + ClassLoaderDataGraph::oops_do(roots, klass_closure, /* must_claim */ false); } else if (so & SO_SystemClasses) { - ClassLoaderDataGraph::always_strong_oops_do(roots, klass_closure, !is_scavenging); + ClassLoaderDataGraph::always_strong_oops_do(roots, klass_closure, /* must_claim */ true); } } @@ -204,17 +205,18 @@ } if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) { - if (so & SO_CodeCache) { + if (so & SO_ScavengeCodeCache) { assert(code_roots != NULL, "must supply closure for code cache"); - if (is_scavenging) { - // We only visit parts of the CodeCache when scavenging. - CodeCache::scavenge_root_nmethods_do(code_roots); - } else { - // CMSCollector uses this to do intermediate-strength collections. - // We scan the entire code cache, since CodeCache::do_unloading is not called. - CodeCache::blobs_do(code_roots); - } + // We only visit parts of the CodeCache when scavenging. + CodeCache::scavenge_root_nmethods_do(code_roots); + } + if (so & SO_AllCodeCache) { + assert(code_roots != NULL, "must supply closure for code cache"); + + // CMSCollector uses this to do intermediate-strength collections. + // We scan the entire code cache, since CodeCache::do_unloading is not called. + CodeCache::blobs_do(code_roots); } // Verify that the code cache contents are not subject to // movement by a scavenging collection. diff -r 7ab52431bc9f -r 870aedf4ba4f src/share/vm/memory/sharedHeap.hpp --- a/src/share/vm/memory/sharedHeap.hpp Mon Jan 20 12:56:18 2014 +0100 +++ b/src/share/vm/memory/sharedHeap.hpp Tue Jan 14 16:40:33 2014 +0100 @@ -221,7 +221,8 @@ SO_AllClasses = 0x1, SO_SystemClasses = 0x2, SO_Strings = 0x4, - SO_CodeCache = 0x8 + SO_AllCodeCache = 0x8, + SO_ScavengeCodeCache = 0x10 }; FlexibleWorkGang* workers() const { return _workers; } @@ -232,9 +233,9 @@ // "SO_AllClasses" applies the closure to all entries in the SystemDictionary; // "SO_SystemClasses" to all the "system" classes and loaders; // "SO_Strings" applies the closure to all entries in StringTable; - // "SO_CodeCache" applies the closure to all elements of the CodeCache. + // "SO_AllCodeCache" applies the closure to all elements of the CodeCache. + // "SO_ScavengeCodeCache" applies the closure to elements on the scavenge root list in the CodeCache. void process_strong_roots(bool activate_scope, - bool is_scavenging, ScanningOption so, OopClosure* roots, CodeBlobClosure* code_roots,