Mercurial > hg > openjdk > jdk8u > hotspot
changeset 6444:7426d8d76305
8034761: Remove the do_code_roots parameter from process_strong_roots
Reviewed-by: tschatzl, mgerdin, jmasa
line wrap: on
line diff
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Feb 13 17:44:39 2014 +0100 @@ -3040,7 +3040,6 @@ true, // activate StrongRootsScope SharedHeap::ScanningOption(roots_scanning_options()), ¬Older, - true, // walk code active on stacks NULL, NULL); // SSS: Provide correct closure @@ -3107,7 +3106,6 @@ true, // activate StrongRootsScope SharedHeap::ScanningOption(roots_scanning_options()), ¬Older, - true, // walk code active on stacks NULL, &klass_closure); @@ -3686,12 +3684,6 @@ 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(); @@ -3744,7 +3736,6 @@ true, // activate StrongRootsScope SharedHeap::ScanningOption(roots_scanning_options()), ¬Older, - true, // walk all of code cache if (so & SO_AllCodeCache) NULL, &klass_closure); } @@ -5243,7 +5234,6 @@ false, // this is parallel code SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()), &par_mri_cl, - true, // walk all of code cache if (so & SO_AllCodeCache) NULL, &klass_closure); assert(_collector->should_unload_classes() @@ -5379,7 +5369,6 @@ false, // this is parallel code SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()), &par_mrias_cl, - true, // walk all of code cache if (so & SO_AllCodeCache) NULL, NULL); // The dirty klasses will be handled below assert(_collector->should_unload_classes() @@ -5969,7 +5958,6 @@ false, // use the local StrongRootsScope SharedHeap::ScanningOption(roots_scanning_options()), &mrias_cl, - true, // walk code active on stacks NULL, NULL); // The dirty klasses will be handled below
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Thu Feb 13 17:44:39 2014 +0100 @@ -1383,13 +1383,6 @@ // Closures of various sorts used by CMS to accomplish its work // -// This closure is used to check that a certain set of oops is empty. -class FalseClosure: public OopClosure { - public: - void do_oop(oop* p) { guarantee(false, "Should be an empty set"); } - void do_oop(narrowOop* p) { guarantee(false, "Should be an empty set"); } -}; - // This closure is used to do concurrent marking from the roots // following the first checkpoint. class MarkFromRootsClosure: public BitMapClosure {
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Thu Feb 13 17:44:39 2014 +0100 @@ -3390,13 +3390,12 @@ if (!silent) { gclog_or_tty->print("Roots "); } VerifyRootsClosure rootsCl(vo); - G1VerifyCodeRootOopClosure codeRootsCl(this, &rootsCl, vo); - G1VerifyCodeRootBlobClosure blobsCl(&codeRootsCl); VerifyKlassClosure klassCl(this, &rootsCl); // 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_AllCodeCache; + // system dictionary, class loader data graph and the string table. + // Don't verify the code cache here, since it's verified below. + const int so = SO_AllClasses | SO_Strings; // Need cleared claim bits for the strong roots processing ClassLoaderDataGraph::clear_claimed_marks(); @@ -3404,10 +3403,14 @@ process_strong_roots(true, // activate StrongRootsScope ScanningOption(so), // roots scanning options &rootsCl, - &blobsCl, &klassCl ); + // Verify the nmethods in the code cache. + G1VerifyCodeRootOopClosure codeRootsCl(this, &rootsCl, vo); + G1VerifyCodeRootBlobClosure blobsCl(&codeRootsCl); + CodeCache::blobs_do(&blobsCl); + bool failures = rootsCl.failures() || codeRootsCl.failures(); if (vo != VerifyOption_G1UseMarkWord) { @@ -4865,12 +4868,9 @@ BufferingOopClosure buf_scan_non_heap_roots(scan_non_heap_roots); - CodeBlobToOopClosure scan_code_roots(&buf_scan_non_heap_roots, true /* do_marking */); - process_strong_roots(false, // no scoping; this is parallel code so, &buf_scan_non_heap_roots, - &scan_code_roots, scan_klasses ); @@ -4930,12 +4930,6 @@ _process_strong_tasks->all_tasks_completed(); } -void -G1CollectedHeap::g1_process_weak_roots(OopClosure* root_closure) { - CodeBlobToOopClosure roots_in_blobs(root_closure, /*do_marking=*/ false); - SharedHeap::process_weak_roots(root_closure, &roots_in_blobs); -} - class G1StringSymbolTableUnlinkTask : public AbstractGangTask { private: BoolObjectClosure* _is_alive;
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Thu Feb 13 17:44:39 2014 +0100 @@ -834,11 +834,6 @@ G1KlassScanClosure* scan_klasses, uint worker_i); - // Apply "blk" to all the weak roots of the system. These include - // JNI weak roots, the code cache, system dictionary, symbol table, - // string table, and referents of reachable weak refs. - void g1_process_weak_roots(OopClosure* root_closure); - // Notifies all the necessary spaces that the committed space has // been updated (either expanded or shrunk). It should be called // after _g1_storage is updated.
--- a/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Thu Feb 13 17:44:39 2014 +0100 @@ -134,7 +134,6 @@ sh->process_strong_roots(true, // activate StrongRootsScope SharedHeap::SO_SystemClasses, &GenMarkSweep::follow_root_closure, - &GenMarkSweep::follow_code_root_closure, &GenMarkSweep::follow_klass_closure); // Process reference objects found during marking @@ -308,9 +307,8 @@ ClassLoaderDataGraph::clear_claimed_marks(); sh->process_strong_roots(true, // activate StrongRootsScope - SharedHeap::SO_AllClasses, + SharedHeap::SO_AllClasses | SharedHeap::SO_AllCodeCache, &GenMarkSweep::adjust_pointer_closure, - NULL, // do not touch code cache here &GenMarkSweep::adjust_klass_closure); assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity"); @@ -318,7 +316,7 @@ // Now adjust pointers in remaining weak roots. (All of which should // have been cleared if they pointed to non-surviving objects.) - g1h->g1_process_weak_roots(&GenMarkSweep::adjust_pointer_closure); + sh->process_weak_roots(&GenMarkSweep::adjust_pointer_closure); if (G1StringDedup::is_enabled()) { G1StringDedup::oops_do(&GenMarkSweep::adjust_pointer_closure);
--- a/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Thu Feb 13 17:44:39 2014 +0100 @@ -623,7 +623,6 @@ false, // no scope; this is parallel code SharedHeap::ScanningOption(so), &par_scan_state.to_space_root_closure(), - true, // walk *all* scavengable nmethods &par_scan_state.older_gen_closure(), &klass_scan_closure); par_scan_state.end_strong_roots();
--- a/src/share/vm/gc_implementation/shared/markSweep.cpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/gc_implementation/shared/markSweep.cpp Thu Feb 13 17:44:39 2014 +0100 @@ -49,7 +49,6 @@ SerialOldTracer* MarkSweep::_gc_tracer = NULL; MarkSweep::FollowRootClosure MarkSweep::follow_root_closure; -CodeBlobToOopClosure MarkSweep::follow_code_root_closure(&MarkSweep::follow_root_closure, /*do_marking=*/ true); void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
--- a/src/share/vm/gc_implementation/shared/markSweep.hpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/gc_implementation/shared/markSweep.hpp Thu Feb 13 17:44:39 2014 +0100 @@ -143,7 +143,6 @@ // Public closures static IsAliveClosure is_alive; static FollowRootClosure follow_root_closure; - static CodeBlobToOopClosure follow_code_root_closure; // => follow_root_closure static MarkAndPushClosure mark_and_push_closure; static FollowKlassClosure follow_klass_closure; static FollowStackClosure follow_stack_closure;
--- a/src/share/vm/memory/defNewGeneration.cpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/memory/defNewGeneration.cpp Thu Feb 13 17:44:39 2014 +0100 @@ -630,7 +630,6 @@ true, // activate StrongRootsScope SharedHeap::ScanningOption(so), &fsc_with_no_gc_barrier, - true, // walk *all* scavengable nmethods &fsc_with_gc_barrier, &klass_scan_closure);
--- a/src/share/vm/memory/genCollectedHeap.cpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/memory/genCollectedHeap.cpp Thu Feb 13 17:44:39 2014 +0100 @@ -599,20 +599,12 @@ bool activate_scope, SharedHeap::ScanningOption so, OopsInGenClosure* not_older_gens, - bool do_code_roots, OopsInGenClosure* older_gens, KlassClosure* klass_closure) { // General strong roots. - if (!do_code_roots) { - 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, so, - not_older_gens, &code_roots, klass_closure); - } + SharedHeap::process_strong_roots(activate_scope, so, + not_older_gens, klass_closure); if (younger_gens_as_roots) { if (!_gen_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) { @@ -634,9 +626,8 @@ _gen_process_strong_tasks->all_tasks_completed(); } -void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure, - CodeBlobClosure* code_roots) { - SharedHeap::process_weak_roots(root_closure, code_roots); +void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure) { + SharedHeap::process_weak_roots(root_closure); // "Local" "weak" refs for (int i = 0; i < _n_gens; i++) { _gens[i]->ref_processor()->weak_oops_do(root_closure);
--- a/src/share/vm/memory/genCollectedHeap.hpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/memory/genCollectedHeap.hpp Thu Feb 13 17:44:39 2014 +0100 @@ -422,15 +422,13 @@ bool activate_scope, SharedHeap::ScanningOption so, OopsInGenClosure* not_older_gens, - bool do_code_roots, OopsInGenClosure* older_gens, KlassClosure* klass_closure); - // Apply "blk" to all the weak roots of the system. These include - // JNI weak roots, the code cache, system dictionary, symbol table, - // string table, and referents of reachable weak refs. - void gen_process_weak_roots(OopClosure* root_closure, - CodeBlobClosure* code_roots); + // Apply "root_closure" to all the weak roots of the system. + // These include JNI weak roots, string table, + // and referents of reachable weak refs. + void gen_process_weak_roots(OopClosure* root_closure); // Set the saved marks of generations, if that makes sense. // In particular, if any generation might iterate over the oops
--- a/src/share/vm/memory/genMarkSweep.cpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/memory/genMarkSweep.cpp Thu Feb 13 17:44:39 2014 +0100 @@ -212,7 +212,6 @@ true, // activate StrongRootsScope SharedHeap::SO_SystemClasses, &follow_root_closure, - true, // walk code active on stacks &follow_root_closure, &follow_klass_closure); @@ -295,18 +294,12 @@ gch->gen_process_strong_roots(level, false, // Younger gens are not roots. true, // activate StrongRootsScope - SharedHeap::SO_AllClasses, + SharedHeap::SO_AllClasses | SharedHeap::SO_AllCodeCache, &adjust_pointer_closure, - false, // do not walk code &adjust_pointer_closure, &adjust_klass_closure); - // Now adjust pointers in remaining weak roots. (All of which should - // have been cleared if they pointed to non-surviving objects.) - CodeBlobToOopClosure adjust_code_pointer_closure(&adjust_pointer_closure, - /*do_marking=*/ false); - gch->gen_process_weak_roots(&adjust_pointer_closure, - &adjust_code_pointer_closure); + gch->gen_process_weak_roots(&adjust_pointer_closure); adjust_marks(); GenAdjustPointersClosure blk;
--- a/src/share/vm/memory/sharedHeap.cpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/memory/sharedHeap.cpp Thu Feb 13 17:44:39 2014 +0100 @@ -141,7 +141,6 @@ void SharedHeap::process_strong_roots(bool activate_scope, ScanningOption so, OopClosure* roots, - CodeBlobClosure* code_roots, KlassClosure* klass_closure) { StrongRootsScope srs(this, activate_scope); @@ -158,15 +157,17 @@ if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do)) JNIHandles::oops_do(roots); + CodeBlobToOopClosure code_roots(roots, true); + 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. if (CollectedHeap::use_parallel_gc_threads()) { - Threads::possibly_parallel_oops_do(roots, roots_from_clds_p, code_roots); + Threads::possibly_parallel_oops_do(roots, roots_from_clds_p, &code_roots); } else { - Threads::oops_do(roots, roots_from_clds_p, code_roots); + Threads::oops_do(roots, roots_from_clds_p, &code_roots); } if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do)) @@ -208,17 +209,17 @@ if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) { if (so & SO_ScavengeCodeCache) { - assert(code_roots != NULL, "must supply closure for code cache"); + assert(&code_roots != NULL, "must supply closure for code cache"); // We only visit parts of the CodeCache when scavenging. - CodeCache::scavenge_root_nmethods_do(code_roots); + CodeCache::scavenge_root_nmethods_do(&code_roots); } if (so & SO_AllCodeCache) { - assert(code_roots != NULL, "must supply closure for code cache"); + 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); + CodeCache::blobs_do(&code_roots); } // Verify that the code cache contents are not subject to // movement by a scavenging collection. @@ -235,12 +236,10 @@ }; static AlwaysTrueClosure always_true; -void SharedHeap::process_weak_roots(OopClosure* root_closure, - CodeBlobClosure* code_roots) { +void SharedHeap::process_weak_roots(OopClosure* root_closure) { // Global (weak) JNI handles JNIHandles::weak_oops_do(&always_true, root_closure); - CodeCache::blobs_do(code_roots); StringTable::oops_do(root_closure); }
--- a/src/share/vm/memory/sharedHeap.hpp Mon Feb 10 12:58:09 2014 +0100 +++ b/src/share/vm/memory/sharedHeap.hpp Thu Feb 13 17:44:39 2014 +0100 @@ -238,14 +238,11 @@ void process_strong_roots(bool activate_scope, ScanningOption so, OopClosure* roots, - CodeBlobClosure* code_roots, KlassClosure* klass_closure); - // Apply "blk" to all the weak roots of the system. These include - // JNI weak roots, the code cache, system dictionary, symbol table, - // string table. - void process_weak_roots(OopClosure* root_closure, - CodeBlobClosure* code_roots); + // Apply "root_closure" to all the weak roots of the system. + // These include JNI weak roots and string table. + void process_weak_roots(OopClosure* root_closure); // The functions below are helper functions that a subclass of // "SharedHeap" can use in the implementation of its virtual @@ -275,4 +272,8 @@ size_t capacity); }; +inline SharedHeap::ScanningOption operator|(SharedHeap::ScanningOption so0, SharedHeap::ScanningOption so1) { + return static_cast<SharedHeap::ScanningOption>(static_cast<int>(so0) | static_cast<int>(so1)); +} + #endif // SHARE_VM_MEMORY_SHAREDHEAP_HPP