From 5571eae19c84899061ae246d8bc239d791c9c41c Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Thu, 2 Jun 2022 10:40:02 -0400 Subject: [PATCH 1/9] v0 --- .../gc/shenandoah/shenandoahClosures.hpp | 36 +++++------- .../shenandoah/shenandoahClosures.inline.hpp | 58 +++++++------------ .../gc/shenandoah/shenandoahConcurrentGC.cpp | 4 +- .../share/gc/shenandoah/shenandoahMark.cpp | 26 +++------ .../shenandoah/shenandoahNMethod.inline.hpp | 2 +- .../gc/shenandoah/shenandoahOopClosures.hpp | 27 --------- 6 files changed, 46 insertions(+), 107 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp index 9f57189d319e4..744d6f1fe6ae9 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp @@ -89,35 +89,31 @@ class ShenandoahUpdateRefsClosure: public ShenandoahOopClosureBase { inline void do_oop_work(T* p); }; -template -class ShenandoahEvacuateUpdateMetadataClosure: public ShenandoahOopClosureBase { -private: - ShenandoahHeap* const _heap; - Thread* const _thread; +template +class ShenandoahEvacuateUpdateRootClosureBase : public ShenandoahOopClosureBase { +protected: + ShenandoahHeap* const _heap; public: - inline ShenandoahEvacuateUpdateMetadataClosure(); - inline void do_oop(oop* p); - inline void do_oop(narrowOop* p); + inline ShenandoahEvacuateUpdateRootClosureBase(); + inline virtual void do_oop(oop* p); + inline virtual void do_oop(narrowOop* p); +protected: + template + inline void do_oop_work(T* p, Thread* t); +}; -private: - template - inline void do_oop_work(T* p); +class ShenandoahEvacuateUpdateMetadataClosure : public ShenandoahEvacuateUpdateRootClosureBase { }; // Context free version, cannot cache calling thread -class ShenandoahEvacuateUpdateRootsClosure : public ShenandoahOopClosureBase { -private: - ShenandoahHeap* const _heap; +class ShenandoahEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { public: inline ShenandoahEvacuateUpdateRootsClosure(); - inline void do_oop(oop* p); - inline void do_oop(narrowOop* p); -protected: - template - inline void do_oop_work(T* p, Thread* thr); + inline virtual void do_oop(oop* p); + inline virtual void do_oop(narrowOop* p); }; -class ShenandoahContextEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootsClosure { +class ShenandoahContextEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { private: Thread* const _thread; public: diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp index 69fa6c1f0ed20..3f8a267390faf 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp @@ -108,18 +108,18 @@ void ShenandoahUpdateRefsClosure::do_oop_work(T* p) { void ShenandoahUpdateRefsClosure::do_oop(oop* p) { do_oop_work(p); } void ShenandoahUpdateRefsClosure::do_oop(narrowOop* p) { do_oop_work(p); } -template -ShenandoahEvacuateUpdateMetadataClosure::ShenandoahEvacuateUpdateMetadataClosure() : - _heap(ShenandoahHeap::heap()), _thread(Thread::current()) { +template +ShenandoahEvacuateUpdateRootClosureBase::ShenandoahEvacuateUpdateRootClosureBase() : + _heap(ShenandoahHeap::heap()) { } -template +template template -void ShenandoahEvacuateUpdateMetadataClosure::do_oop_work(T* p) { +void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p, Thread* t) { assert(_heap->is_concurrent_weak_root_in_progress() || _heap->is_concurrent_strong_root_in_progress(), "Only do this in root processing phase"); - assert(_thread == Thread::current(), "Wrong thread"); + assert(t == Thread::current(), "Wrong thread"); T o = RawAccess<>::oop_load(p); if (! CompressedOops::is_null(o)) { @@ -129,46 +129,28 @@ void ShenandoahEvacuateUpdateMetadataClosure::do_oop_work(T* p) { shenandoah_assert_marked(p, obj); oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj); if (resolved == obj) { - resolved = _heap->evacuate_object(obj, _thread); + resolved = _heap->evacuate_object(obj, t); + } + if (atomic) { + ShenandoahHeap::atomic_update_oop(resolved, p, o); + } else { + RawAccess::oop_store(p, resolved); } - RawAccess::oop_store(p, resolved); } } } -template -void ShenandoahEvacuateUpdateMetadataClosure::do_oop(oop* p) { - do_oop_work(p); +template +void ShenandoahEvacuateUpdateRootClosureBase::do_oop(oop* p) { + do_oop_work(p, Thread::current()); } -template -void ShenandoahEvacuateUpdateMetadataClosure::do_oop(narrowOop* p) { - do_oop_work(p); +template +void ShenandoahEvacuateUpdateRootClosureBase::do_oop(narrowOop* p) { + do_oop_work(p, Thread::current()); } ShenandoahEvacuateUpdateRootsClosure::ShenandoahEvacuateUpdateRootsClosure() : - _heap(ShenandoahHeap::heap()) { -} - -template -void ShenandoahEvacuateUpdateRootsClosure::do_oop_work(T* p, Thread* t) { - assert(_heap->is_concurrent_weak_root_in_progress() || - _heap->is_concurrent_strong_root_in_progress(), - "Only do this in root processing phase"); - assert(t == Thread::current(), "Wrong thread"); - - T o = RawAccess<>::oop_load(p); - if (!CompressedOops::is_null(o)) { - oop obj = CompressedOops::decode_not_null(o); - if (_heap->in_collection_set(obj)) { - assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress"); - shenandoah_assert_marked(p, obj); - oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj); - if (resolved == obj) { - resolved = _heap->evacuate_object(obj, t); - } - ShenandoahHeap::atomic_update_oop(resolved, p, o); - } - } + ShenandoahEvacuateUpdateRootClosureBase() { } void ShenandoahEvacuateUpdateRootsClosure::do_oop(oop* p) { @@ -182,7 +164,7 @@ void ShenandoahEvacuateUpdateRootsClosure::do_oop(narrowOop* p) { } ShenandoahContextEvacuateUpdateRootsClosure::ShenandoahContextEvacuateUpdateRootsClosure() : - ShenandoahEvacuateUpdateRootsClosure(), + ShenandoahEvacuateUpdateRootClosureBase(), _thread(Thread::current()) { } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp index dec4f6959e921..2dbcad4e8ceb3 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp @@ -834,7 +834,7 @@ void ShenandoahConcurrentGC::op_class_unloading() { class ShenandoahEvacUpdateCodeCacheClosure : public NMethodClosure { private: BarrierSetNMethod* const _bs; - ShenandoahEvacuateUpdateMetadataClosure<> _cl; + ShenandoahEvacuateUpdateMetadataClosure _cl; public: ShenandoahEvacUpdateCodeCacheClosure() : @@ -893,7 +893,7 @@ class ShenandoahConcurrentRootsEvacUpdateTask : public WorkerTask { } { - ShenandoahEvacuateUpdateMetadataClosure<> cl; + ShenandoahEvacuateUpdateMetadataClosure cl; CLDToOopClosure clds(&cl, ClassLoaderData::_claim_strong); _cld_roots.cld_do(&clds, worker_id); } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahMark.cpp b/src/hotspot/share/gc/shenandoah/shenandoahMark.cpp index 165d1c1d5a821..c7a9da36a4ddc 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahMark.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahMark.cpp @@ -78,26 +78,14 @@ void ShenandoahMark::mark_loop_prework(uint w, TaskTerminator *t, ShenandoahRefe // TODO: We can clean up this if we figure out how to do templated oop closures that // play nice with specialized_oop_iterators. - if (heap->unload_classes()) { - if (heap->has_forwarded_objects()) { - using Closure = ShenandoahMarkUpdateRefsMetadataClosure; - Closure cl(q, rp); - mark_loop_work(&cl, ld, w, t, req); - } else { - using Closure = ShenandoahMarkRefsMetadataClosure; - Closure cl(q, rp); - mark_loop_work(&cl, ld, w, t, req); - } + if (heap->has_forwarded_objects()) { + using Closure = ShenandoahMarkUpdateRefsClosure; + Closure cl(q, rp); + mark_loop_work(&cl, ld, w, t, req); } else { - if (heap->has_forwarded_objects()) { - using Closure = ShenandoahMarkUpdateRefsClosure; - Closure cl(q, rp); - mark_loop_work(&cl, ld, w, t, req); - } else { - using Closure = ShenandoahMarkRefsClosure; - Closure cl(q, rp); - mark_loop_work(&cl, ld, w, t, req); - } + using Closure = ShenandoahMarkRefsClosure; + Closure cl(q, rp); + mark_loop_work(&cl, ld, w, t, req); } heap->flush_liveness_cache(w); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp index c134abf19a6f8..f86da7af838c0 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp @@ -74,7 +74,7 @@ void ShenandoahNMethod::oops_do(OopClosure* oops, bool fix_relocations) { } void ShenandoahNMethod::heal_nmethod_metadata(ShenandoahNMethod* nmethod_data) { - ShenandoahEvacuateUpdateMetadataClosure<> cl; + ShenandoahEvacuateUpdateMetadataClosure cl; nmethod_data->oops_do(&cl, true /*fix relocation*/); } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahOopClosures.hpp b/src/hotspot/share/gc/shenandoah/shenandoahOopClosures.hpp index 7f546f1f75054..80a017227f6e4 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahOopClosures.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahOopClosures.hpp @@ -94,20 +94,6 @@ class ShenandoahMarkUpdateRefsClosure : public ShenandoahMarkUpdateRefsSuperClos virtual void do_oop(oop* p) { do_oop_work(p); } }; -class ShenandoahMarkUpdateRefsMetadataClosure : public ShenandoahMarkUpdateRefsSuperClosure { -private: - template - inline void do_oop_work(T* p) { work(p); } - -public: - ShenandoahMarkUpdateRefsMetadataClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp) : - ShenandoahMarkUpdateRefsSuperClosure(q, rp) {} - - virtual void do_oop(narrowOop* p) { do_oop_work(p); } - virtual void do_oop(oop* p) { do_oop_work(p); } -}; - - class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure { private: template @@ -122,19 +108,6 @@ class ShenandoahMarkRefsClosure : public ShenandoahMarkRefsSuperClosure { }; -class ShenandoahMarkRefsMetadataClosure : public ShenandoahMarkRefsSuperClosure { -private: - template - inline void do_oop_work(T* p) { work(p); } - -public: - ShenandoahMarkRefsMetadataClosure(ShenandoahObjToScanQueue* q, ShenandoahReferenceProcessor* rp) : - ShenandoahMarkRefsSuperClosure(q, rp) {}; - - virtual void do_oop(narrowOop* p) { do_oop_work(p); } - virtual void do_oop(oop* p) { do_oop_work(p); } -}; - class ShenandoahUpdateRefsSuperClosure : public ShenandoahOopClosureBase { protected: ShenandoahHeap* _heap; From c7b51e3115a0e9cb5d8e3386991050a1c73d463c Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Thu, 2 Jun 2022 10:58:29 -0400 Subject: [PATCH 2/9] v0 --- .../gc/shenandoah/shenandoahClosures.hpp | 36 +++++++----- .../shenandoah/shenandoahClosures.inline.hpp | 58 ++++++++++++------- .../gc/shenandoah/shenandoahConcurrentGC.cpp | 4 +- .../shenandoah/shenandoahNMethod.inline.hpp | 2 +- 4 files changed, 61 insertions(+), 39 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp index 744d6f1fe6ae9..9f57189d319e4 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp @@ -89,31 +89,35 @@ class ShenandoahUpdateRefsClosure: public ShenandoahOopClosureBase { inline void do_oop_work(T* p); }; -template -class ShenandoahEvacuateUpdateRootClosureBase : public ShenandoahOopClosureBase { -protected: - ShenandoahHeap* const _heap; +template +class ShenandoahEvacuateUpdateMetadataClosure: public ShenandoahOopClosureBase { +private: + ShenandoahHeap* const _heap; + Thread* const _thread; public: - inline ShenandoahEvacuateUpdateRootClosureBase(); - inline virtual void do_oop(oop* p); - inline virtual void do_oop(narrowOop* p); -protected: - template - inline void do_oop_work(T* p, Thread* t); -}; + inline ShenandoahEvacuateUpdateMetadataClosure(); + inline void do_oop(oop* p); + inline void do_oop(narrowOop* p); -class ShenandoahEvacuateUpdateMetadataClosure : public ShenandoahEvacuateUpdateRootClosureBase { +private: + template + inline void do_oop_work(T* p); }; // Context free version, cannot cache calling thread -class ShenandoahEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { +class ShenandoahEvacuateUpdateRootsClosure : public ShenandoahOopClosureBase { +private: + ShenandoahHeap* const _heap; public: inline ShenandoahEvacuateUpdateRootsClosure(); - inline virtual void do_oop(oop* p); - inline virtual void do_oop(narrowOop* p); + inline void do_oop(oop* p); + inline void do_oop(narrowOop* p); +protected: + template + inline void do_oop_work(T* p, Thread* thr); }; -class ShenandoahContextEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { +class ShenandoahContextEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootsClosure { private: Thread* const _thread; public: diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp index 3f8a267390faf..69fa6c1f0ed20 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp @@ -108,18 +108,18 @@ void ShenandoahUpdateRefsClosure::do_oop_work(T* p) { void ShenandoahUpdateRefsClosure::do_oop(oop* p) { do_oop_work(p); } void ShenandoahUpdateRefsClosure::do_oop(narrowOop* p) { do_oop_work(p); } -template -ShenandoahEvacuateUpdateRootClosureBase::ShenandoahEvacuateUpdateRootClosureBase() : - _heap(ShenandoahHeap::heap()) { +template +ShenandoahEvacuateUpdateMetadataClosure::ShenandoahEvacuateUpdateMetadataClosure() : + _heap(ShenandoahHeap::heap()), _thread(Thread::current()) { } -template +template template -void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p, Thread* t) { +void ShenandoahEvacuateUpdateMetadataClosure::do_oop_work(T* p) { assert(_heap->is_concurrent_weak_root_in_progress() || _heap->is_concurrent_strong_root_in_progress(), "Only do this in root processing phase"); - assert(t == Thread::current(), "Wrong thread"); + assert(_thread == Thread::current(), "Wrong thread"); T o = RawAccess<>::oop_load(p); if (! CompressedOops::is_null(o)) { @@ -129,28 +129,46 @@ void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p, Thread* shenandoah_assert_marked(p, obj); oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj); if (resolved == obj) { - resolved = _heap->evacuate_object(obj, t); - } - if (atomic) { - ShenandoahHeap::atomic_update_oop(resolved, p, o); - } else { - RawAccess::oop_store(p, resolved); + resolved = _heap->evacuate_object(obj, _thread); } + RawAccess::oop_store(p, resolved); } } } -template -void ShenandoahEvacuateUpdateRootClosureBase::do_oop(oop* p) { - do_oop_work(p, Thread::current()); +template +void ShenandoahEvacuateUpdateMetadataClosure::do_oop(oop* p) { + do_oop_work(p); } -template -void ShenandoahEvacuateUpdateRootClosureBase::do_oop(narrowOop* p) { - do_oop_work(p, Thread::current()); +template +void ShenandoahEvacuateUpdateMetadataClosure::do_oop(narrowOop* p) { + do_oop_work(p); } ShenandoahEvacuateUpdateRootsClosure::ShenandoahEvacuateUpdateRootsClosure() : - ShenandoahEvacuateUpdateRootClosureBase() { + _heap(ShenandoahHeap::heap()) { +} + +template +void ShenandoahEvacuateUpdateRootsClosure::do_oop_work(T* p, Thread* t) { + assert(_heap->is_concurrent_weak_root_in_progress() || + _heap->is_concurrent_strong_root_in_progress(), + "Only do this in root processing phase"); + assert(t == Thread::current(), "Wrong thread"); + + T o = RawAccess<>::oop_load(p); + if (!CompressedOops::is_null(o)) { + oop obj = CompressedOops::decode_not_null(o); + if (_heap->in_collection_set(obj)) { + assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress"); + shenandoah_assert_marked(p, obj); + oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj); + if (resolved == obj) { + resolved = _heap->evacuate_object(obj, t); + } + ShenandoahHeap::atomic_update_oop(resolved, p, o); + } + } } void ShenandoahEvacuateUpdateRootsClosure::do_oop(oop* p) { @@ -164,7 +182,7 @@ void ShenandoahEvacuateUpdateRootsClosure::do_oop(narrowOop* p) { } ShenandoahContextEvacuateUpdateRootsClosure::ShenandoahContextEvacuateUpdateRootsClosure() : - ShenandoahEvacuateUpdateRootClosureBase(), + ShenandoahEvacuateUpdateRootsClosure(), _thread(Thread::current()) { } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp index 2dbcad4e8ceb3..dec4f6959e921 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp @@ -834,7 +834,7 @@ void ShenandoahConcurrentGC::op_class_unloading() { class ShenandoahEvacUpdateCodeCacheClosure : public NMethodClosure { private: BarrierSetNMethod* const _bs; - ShenandoahEvacuateUpdateMetadataClosure _cl; + ShenandoahEvacuateUpdateMetadataClosure<> _cl; public: ShenandoahEvacUpdateCodeCacheClosure() : @@ -893,7 +893,7 @@ class ShenandoahConcurrentRootsEvacUpdateTask : public WorkerTask { } { - ShenandoahEvacuateUpdateMetadataClosure cl; + ShenandoahEvacuateUpdateMetadataClosure<> cl; CLDToOopClosure clds(&cl, ClassLoaderData::_claim_strong); _cld_roots.cld_do(&clds, worker_id); } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp index f86da7af838c0..c134abf19a6f8 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp @@ -74,7 +74,7 @@ void ShenandoahNMethod::oops_do(OopClosure* oops, bool fix_relocations) { } void ShenandoahNMethod::heal_nmethod_metadata(ShenandoahNMethod* nmethod_data) { - ShenandoahEvacuateUpdateMetadataClosure cl; + ShenandoahEvacuateUpdateMetadataClosure<> cl; nmethod_data->oops_do(&cl, true /*fix relocation*/); } From c3a41277882d2fee805f760bfc398a41f9d0ad3c Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Fri, 3 Jun 2022 09:39:52 -0400 Subject: [PATCH 3/9] 8287805: Shenandoah: consolidate evacuate-update-root closures --- .../gc/shenandoah/shenandoahClosures.hpp | 37 +++++------- .../shenandoah/shenandoahClosures.inline.hpp | 58 +++++++------------ .../gc/shenandoah/shenandoahConcurrentGC.cpp | 4 +- .../shenandoah/shenandoahNMethod.inline.hpp | 4 +- 4 files changed, 40 insertions(+), 63 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp index 9f57189d319e4..0f9ac02518ff3 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp @@ -89,35 +89,30 @@ class ShenandoahUpdateRefsClosure: public ShenandoahOopClosureBase { inline void do_oop_work(T* p); }; -template -class ShenandoahEvacuateUpdateMetadataClosure: public ShenandoahOopClosureBase { -private: - ShenandoahHeap* const _heap; - Thread* const _thread; +template +class ShenandoahEvacuateUpdateRootClosureBase : public ShenandoahOopClosureBase { +protected: + ShenandoahHeap* const _heap; public: - inline ShenandoahEvacuateUpdateMetadataClosure(); - inline void do_oop(oop* p); - inline void do_oop(narrowOop* p); - -private: - template - inline void do_oop_work(T* p); + inline ShenandoahEvacuateUpdateRootClosureBase(); + inline virtual void do_oop(oop* p); + inline virtual void do_oop(narrowOop* p); +protected: + template + inline void do_oop_work(T* p, Thread* t); }; +using ShenandoahEvacuateUpdateMetadataClosure = ShenandoahEvacuateUpdateRootClosureBase; + // Context free version, cannot cache calling thread -class ShenandoahEvacuateUpdateRootsClosure : public ShenandoahOopClosureBase { -private: - ShenandoahHeap* const _heap; +class ShenandoahEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { public: inline ShenandoahEvacuateUpdateRootsClosure(); - inline void do_oop(oop* p); - inline void do_oop(narrowOop* p); -protected: - template - inline void do_oop_work(T* p, Thread* thr); + inline virtual void do_oop(oop* p); + inline virtual void do_oop(narrowOop* p); }; -class ShenandoahContextEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootsClosure { +class ShenandoahContextEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { private: Thread* const _thread; public: diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp index 69fa6c1f0ed20..3f8a267390faf 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp @@ -108,18 +108,18 @@ void ShenandoahUpdateRefsClosure::do_oop_work(T* p) { void ShenandoahUpdateRefsClosure::do_oop(oop* p) { do_oop_work(p); } void ShenandoahUpdateRefsClosure::do_oop(narrowOop* p) { do_oop_work(p); } -template -ShenandoahEvacuateUpdateMetadataClosure::ShenandoahEvacuateUpdateMetadataClosure() : - _heap(ShenandoahHeap::heap()), _thread(Thread::current()) { +template +ShenandoahEvacuateUpdateRootClosureBase::ShenandoahEvacuateUpdateRootClosureBase() : + _heap(ShenandoahHeap::heap()) { } -template +template template -void ShenandoahEvacuateUpdateMetadataClosure::do_oop_work(T* p) { +void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p, Thread* t) { assert(_heap->is_concurrent_weak_root_in_progress() || _heap->is_concurrent_strong_root_in_progress(), "Only do this in root processing phase"); - assert(_thread == Thread::current(), "Wrong thread"); + assert(t == Thread::current(), "Wrong thread"); T o = RawAccess<>::oop_load(p); if (! CompressedOops::is_null(o)) { @@ -129,46 +129,28 @@ void ShenandoahEvacuateUpdateMetadataClosure::do_oop_work(T* p) { shenandoah_assert_marked(p, obj); oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj); if (resolved == obj) { - resolved = _heap->evacuate_object(obj, _thread); + resolved = _heap->evacuate_object(obj, t); + } + if (atomic) { + ShenandoahHeap::atomic_update_oop(resolved, p, o); + } else { + RawAccess::oop_store(p, resolved); } - RawAccess::oop_store(p, resolved); } } } -template -void ShenandoahEvacuateUpdateMetadataClosure::do_oop(oop* p) { - do_oop_work(p); +template +void ShenandoahEvacuateUpdateRootClosureBase::do_oop(oop* p) { + do_oop_work(p, Thread::current()); } -template -void ShenandoahEvacuateUpdateMetadataClosure::do_oop(narrowOop* p) { - do_oop_work(p); +template +void ShenandoahEvacuateUpdateRootClosureBase::do_oop(narrowOop* p) { + do_oop_work(p, Thread::current()); } ShenandoahEvacuateUpdateRootsClosure::ShenandoahEvacuateUpdateRootsClosure() : - _heap(ShenandoahHeap::heap()) { -} - -template -void ShenandoahEvacuateUpdateRootsClosure::do_oop_work(T* p, Thread* t) { - assert(_heap->is_concurrent_weak_root_in_progress() || - _heap->is_concurrent_strong_root_in_progress(), - "Only do this in root processing phase"); - assert(t == Thread::current(), "Wrong thread"); - - T o = RawAccess<>::oop_load(p); - if (!CompressedOops::is_null(o)) { - oop obj = CompressedOops::decode_not_null(o); - if (_heap->in_collection_set(obj)) { - assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress"); - shenandoah_assert_marked(p, obj); - oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj); - if (resolved == obj) { - resolved = _heap->evacuate_object(obj, t); - } - ShenandoahHeap::atomic_update_oop(resolved, p, o); - } - } + ShenandoahEvacuateUpdateRootClosureBase() { } void ShenandoahEvacuateUpdateRootsClosure::do_oop(oop* p) { @@ -182,7 +164,7 @@ void ShenandoahEvacuateUpdateRootsClosure::do_oop(narrowOop* p) { } ShenandoahContextEvacuateUpdateRootsClosure::ShenandoahContextEvacuateUpdateRootsClosure() : - ShenandoahEvacuateUpdateRootsClosure(), + ShenandoahEvacuateUpdateRootClosureBase(), _thread(Thread::current()) { } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp index dec4f6959e921..2dbcad4e8ceb3 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahConcurrentGC.cpp @@ -834,7 +834,7 @@ void ShenandoahConcurrentGC::op_class_unloading() { class ShenandoahEvacUpdateCodeCacheClosure : public NMethodClosure { private: BarrierSetNMethod* const _bs; - ShenandoahEvacuateUpdateMetadataClosure<> _cl; + ShenandoahEvacuateUpdateMetadataClosure _cl; public: ShenandoahEvacUpdateCodeCacheClosure() : @@ -893,7 +893,7 @@ class ShenandoahConcurrentRootsEvacUpdateTask : public WorkerTask { } { - ShenandoahEvacuateUpdateMetadataClosure<> cl; + ShenandoahEvacuateUpdateMetadataClosure cl; CLDToOopClosure clds(&cl, ClassLoaderData::_claim_strong); _cld_roots.cld_do(&clds, worker_id); } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp index c134abf19a6f8..dc559228ccf53 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahNMethod.inline.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2019, 2021, Red Hat, Inc. All rights reserved. + * Copyright (c) 2019, 2022, Red Hat, Inc. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -74,7 +74,7 @@ void ShenandoahNMethod::oops_do(OopClosure* oops, bool fix_relocations) { } void ShenandoahNMethod::heal_nmethod_metadata(ShenandoahNMethod* nmethod_data) { - ShenandoahEvacuateUpdateMetadataClosure<> cl; + ShenandoahEvacuateUpdateMetadataClosure cl; nmethod_data->oops_do(&cl, true /*fix relocation*/); } From 427c3a457a7fdb1eb024cc9ef75f9a220095a256 Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Thu, 23 Jun 2022 13:45:16 -0400 Subject: [PATCH 4/9] Review feedback --- .../gc/shenandoah/shenandoahClosures.hpp | 25 ++++++++++++------- .../shenandoah/shenandoahClosures.inline.hpp | 12 +++++++++ 2 files changed, 28 insertions(+), 9 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp index 0f9ac02518ff3..6f0d2070b88ce 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp @@ -92,24 +92,31 @@ class ShenandoahUpdateRefsClosure: public ShenandoahOopClosureBase { template class ShenandoahEvacuateUpdateRootClosureBase : public ShenandoahOopClosureBase { protected: - ShenandoahHeap* const _heap; + ShenandoahHeap* const _heap; public: - inline ShenandoahEvacuateUpdateRootClosureBase(); - inline virtual void do_oop(oop* p); - inline virtual void do_oop(narrowOop* p); + inline ShenandoahEvacuateUpdateRootClosureBase(); + inline void do_oop(oop* p); + inline void do_oop(narrowOop* p); protected: - template - inline void do_oop_work(T* p, Thread* t); + template + inline void do_oop_work(T* p, Thread* t); }; -using ShenandoahEvacuateUpdateMetadataClosure = ShenandoahEvacuateUpdateRootClosureBase; +class ShenandoahEvacuateUpdateMetadataClosure : public ShenandoahEvacuateUpdateRootClosureBase { +private: + Thread* const _thread; +public: + inline ShenandoahEvacuateUpdateMetadataClosure(); + inline void do_oop(oop* p); + inline void do_oop(narrowOop* p); +}; // Context free version, cannot cache calling thread class ShenandoahEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { public: inline ShenandoahEvacuateUpdateRootsClosure(); - inline virtual void do_oop(oop* p); - inline virtual void do_oop(narrowOop* p); + inline void do_oop(oop* p); + inline void do_oop(narrowOop* p); }; class ShenandoahContextEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp index 3e37aae75bf5d..3add2890dfdd8 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp @@ -150,6 +150,18 @@ void ShenandoahEvacuateUpdateRootClosureBase::do_oop(narrowOop* p) { do_oop_work(p, Thread::current()); } +ShenandoahEvacuateUpdateMetadataClosure::ShenandoahEvacuateUpdateMetadataClosure() : + ShenandoahEvacuateUpdateRootClosureBase(), _thread(Thread::current()) { +} + +void ShenandoahEvacuateUpdateMetadataClosure::do_oop(oop* p) { + do_oop_work(p, _thread); +} + +void ShenandoahEvacuateUpdateMetadataClosure::do_oop(narrowOop* p) { + do_oop_work(p, _thread); +} + ShenandoahEvacuateUpdateRootsClosure::ShenandoahEvacuateUpdateRootsClosure() : ShenandoahEvacuateUpdateRootClosureBase() { } From 689335bfd703da834e6eecb905a665eb58306d44 Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Thu, 23 Jun 2022 14:02:19 -0400 Subject: [PATCH 5/9] Remove unused impl --- src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp | 2 -- .../share/gc/shenandoah/shenandoahClosures.inline.hpp | 9 --------- 2 files changed, 11 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp index 6f0d2070b88ce..3f2a74ebcc9f6 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp @@ -95,8 +95,6 @@ class ShenandoahEvacuateUpdateRootClosureBase : public ShenandoahOopClosureBase ShenandoahHeap* const _heap; public: inline ShenandoahEvacuateUpdateRootClosureBase(); - inline void do_oop(oop* p); - inline void do_oop(narrowOop* p); protected: template inline void do_oop_work(T* p, Thread* t); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp index 3add2890dfdd8..23ebe0e5cb030 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp @@ -140,15 +140,6 @@ void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p, Thread* } } } -template -void ShenandoahEvacuateUpdateRootClosureBase::do_oop(oop* p) { - do_oop_work(p, Thread::current()); -} - -template -void ShenandoahEvacuateUpdateRootClosureBase::do_oop(narrowOop* p) { - do_oop_work(p, Thread::current()); -} ShenandoahEvacuateUpdateMetadataClosure::ShenandoahEvacuateUpdateMetadataClosure() : ShenandoahEvacuateUpdateRootClosureBase(), _thread(Thread::current()) { From 91fec5d819e89e395525dae40623dceb7e559db0 Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Thu, 30 Jun 2022 12:59:38 -0400 Subject: [PATCH 6/9] v1 --- .../gc/shenandoah/shenandoahClosures.hpp | 33 ++--------- .../shenandoah/shenandoahClosures.inline.hpp | 55 +++---------------- 2 files changed, 14 insertions(+), 74 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp index 3f2a74ebcc9f6..4201f11faa4d4 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp @@ -89,42 +89,21 @@ class ShenandoahUpdateRefsClosure: public ShenandoahOopClosureBase { inline void do_oop_work(T* p); }; -template +template class ShenandoahEvacuateUpdateRootClosureBase : public ShenandoahOopClosureBase { protected: ShenandoahHeap* const _heap; + Thread* const _thread; public: inline ShenandoahEvacuateUpdateRootClosureBase(); protected: template - inline void do_oop_work(T* p, Thread* t); -}; - -class ShenandoahEvacuateUpdateMetadataClosure : public ShenandoahEvacuateUpdateRootClosureBase { -private: - Thread* const _thread; -public: - inline ShenandoahEvacuateUpdateMetadataClosure(); - inline void do_oop(oop* p); - inline void do_oop(narrowOop* p); -}; - -// Context free version, cannot cache calling thread -class ShenandoahEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { -public: - inline ShenandoahEvacuateUpdateRootsClosure(); - inline void do_oop(oop* p); - inline void do_oop(narrowOop* p); + inline void do_oop_work(T* p); }; -class ShenandoahContextEvacuateUpdateRootsClosure : public ShenandoahEvacuateUpdateRootClosureBase { -private: - Thread* const _thread; -public: - inline ShenandoahContextEvacuateUpdateRootsClosure(); - inline void do_oop(oop* p); - inline void do_oop(narrowOop* p); -}; +using ShenandoahEvacuateUpdateMetadataClosure = ShenandoahEvacuateUpdateRootClosureBase; +using ShenandoahEvacuateUpdateRootsClosure = ShenandoahEvacuateUpdateRootClosureBase; +using ShenandoahContextEvacuateUpdateRootsClosure = ShenandoahEvacuateUpdateRootClosureBase; template class ShenandoahCleanUpdateWeakOopsClosure : public OopClosure { diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp index 23ebe0e5cb030..1d6a603454683 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp @@ -109,18 +109,20 @@ void ShenandoahUpdateRefsClosure::do_oop_work(T* p) { void ShenandoahUpdateRefsClosure::do_oop(oop* p) { do_oop_work(p); } void ShenandoahUpdateRefsClosure::do_oop(narrowOop* p) { do_oop_work(p); } -template +template ShenandoahEvacuateUpdateRootClosureBase::ShenandoahEvacuateUpdateRootClosureBase() : - _heap(ShenandoahHeap::heap()) { + _heap(ShenandoahHeap::heap()), _thread(stable_thread ? Thread::current() : NULL) { } -template +template template -void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p, Thread* t) { +void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p) { assert(_heap->is_concurrent_weak_root_in_progress() || _heap->is_concurrent_strong_root_in_progress(), "Only do this in root processing phase"); - assert(t == Thread::current(), "Wrong thread"); + + Thread* thr = stable_thread ? _thread : Thread::current(); + assert(thr == Thread::current(), "Wrong thread"); T o = RawAccess<>::oop_load(p); if (! CompressedOops::is_null(o)) { @@ -130,7 +132,7 @@ void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p, Thread* shenandoah_assert_marked(p, obj); oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj); if (resolved == obj) { - resolved = _heap->evacuate_object(obj, t); + resolved = _heap->evacuate_object(obj, thr); } if (atomic) { ShenandoahHeap::atomic_update_oop(resolved, p, o); @@ -141,47 +143,6 @@ void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p, Thread* } } -ShenandoahEvacuateUpdateMetadataClosure::ShenandoahEvacuateUpdateMetadataClosure() : - ShenandoahEvacuateUpdateRootClosureBase(), _thread(Thread::current()) { -} - -void ShenandoahEvacuateUpdateMetadataClosure::do_oop(oop* p) { - do_oop_work(p, _thread); -} - -void ShenandoahEvacuateUpdateMetadataClosure::do_oop(narrowOop* p) { - do_oop_work(p, _thread); -} - -ShenandoahEvacuateUpdateRootsClosure::ShenandoahEvacuateUpdateRootsClosure() : - ShenandoahEvacuateUpdateRootClosureBase() { -} - -void ShenandoahEvacuateUpdateRootsClosure::do_oop(oop* p) { - ShenandoahEvacOOMScope scope; - do_oop_work(p, Thread::current()); -} - -void ShenandoahEvacuateUpdateRootsClosure::do_oop(narrowOop* p) { - ShenandoahEvacOOMScope scope; - do_oop_work(p, Thread::current()); -} - -ShenandoahContextEvacuateUpdateRootsClosure::ShenandoahContextEvacuateUpdateRootsClosure() : - ShenandoahEvacuateUpdateRootClosureBase(), - _thread(Thread::current()) { -} - -void ShenandoahContextEvacuateUpdateRootsClosure::do_oop(oop* p) { - ShenandoahEvacOOMScope scope; - do_oop_work(p, _thread); -} - -void ShenandoahContextEvacuateUpdateRootsClosure::do_oop(narrowOop* p) { - ShenandoahEvacOOMScope scope; - do_oop_work(p, _thread); -} - template ShenandoahCleanUpdateWeakOopsClosure::ShenandoahCleanUpdateWeakOopsClosure(IsAlive* is_alive, KeepAlive* keep_alive) : _is_alive(is_alive), _keep_alive(keep_alive) { From f076e810240c92f24530104a7260c38957ed1542 Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Thu, 30 Jun 2022 15:36:13 -0400 Subject: [PATCH 7/9] Aleksey's comment --- .../gc/shenandoah/shenandoahClosures.hpp | 4 ++- .../shenandoah/shenandoahClosures.inline.hpp | 26 ++++++++++++++++--- 2 files changed, 26 insertions(+), 4 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp index 4201f11faa4d4..cba3be0311c56 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.hpp @@ -89,13 +89,15 @@ class ShenandoahUpdateRefsClosure: public ShenandoahOopClosureBase { inline void do_oop_work(T* p); }; -template +template class ShenandoahEvacuateUpdateRootClosureBase : public ShenandoahOopClosureBase { protected: ShenandoahHeap* const _heap; Thread* const _thread; public: inline ShenandoahEvacuateUpdateRootClosureBase(); + inline void do_oop(oop* p); + inline void do_oop(narrowOop* p); protected: template inline void do_oop_work(T* p); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp index 1d6a603454683..f54b3fe0b4b38 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp @@ -109,14 +109,34 @@ void ShenandoahUpdateRefsClosure::do_oop_work(T* p) { void ShenandoahUpdateRefsClosure::do_oop(oop* p) { do_oop_work(p); } void ShenandoahUpdateRefsClosure::do_oop(narrowOop* p) { do_oop_work(p); } -template -ShenandoahEvacuateUpdateRootClosureBase::ShenandoahEvacuateUpdateRootClosureBase() : +template +ShenandoahEvacuateUpdateRootClosureBase::ShenandoahEvacuateUpdateRootClosureBase() : _heap(ShenandoahHeap::heap()), _thread(stable_thread ? Thread::current() : NULL) { } +template +void ShenandoahEvacuateUpdateRootClosureBase::do_oop(oop* p) { + if (concurrent) { + ShenandoahEvacOOMScope scope; + do_oop_work(p); + } else { + do_oop_work(p); + } +} + +template +void ShenandoahEvacuateUpdateRootClosureBase::do_oop(narrowOop* p) { + if (concurrent) { + ShenandoahEvacOOMScope scope; + do_oop_work(p); + } else { + do_oop_work(p); + } +} + template template -void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p) { +void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work(T* p) { assert(_heap->is_concurrent_weak_root_in_progress() || _heap->is_concurrent_strong_root_in_progress(), "Only do this in root processing phase"); From 44f5083966f147693a7dc0ea5049a67681f3fd54 Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Mon, 11 Jul 2022 10:18:46 -0400 Subject: [PATCH 8/9] Aleksey's comment --- .../share/gc/shenandoah/shenandoahClosures.inline.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp index f54b3fe0b4b38..c1d5811c9717b 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp @@ -141,13 +141,13 @@ void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work _heap->is_concurrent_strong_root_in_progress(), "Only do this in root processing phase"); - Thread* thr = stable_thread ? _thread : Thread::current(); - assert(thr == Thread::current(), "Wrong thread"); - T o = RawAccess<>::oop_load(p); - if (! CompressedOops::is_null(o)) { + if (!CompressedOops::is_null(o)) { oop obj = CompressedOops::decode_not_null(o); if (_heap->in_collection_set(obj)) { + Thread* thr = stable_thread ? _thread : Thread::current(); + assert(thr == Thread::current(), "Wrong thread"); + assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress"); shenandoah_assert_marked(p, obj); oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj); From b38bddf6b9138c568fae16498fa2774eb903571f Mon Sep 17 00:00:00 2001 From: Zhengyu Gu Date: Mon, 18 Jul 2022 08:59:28 -0400 Subject: [PATCH 9/9] Move get thread closer to the use --- .../share/gc/shenandoah/shenandoahClosures.inline.hpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp index c1d5811c9717b..07660506d60bc 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahClosures.inline.hpp @@ -145,13 +145,13 @@ void ShenandoahEvacuateUpdateRootClosureBase::do_oop_work if (!CompressedOops::is_null(o)) { oop obj = CompressedOops::decode_not_null(o); if (_heap->in_collection_set(obj)) { - Thread* thr = stable_thread ? _thread : Thread::current(); - assert(thr == Thread::current(), "Wrong thread"); - assert(_heap->is_evacuation_in_progress(), "Only do this when evacuation is in progress"); shenandoah_assert_marked(p, obj); oop resolved = ShenandoahBarrierSet::resolve_forwarded_not_null(obj); if (resolved == obj) { + Thread* thr = stable_thread ? _thread : Thread::current(); + assert(thr == Thread::current(), "Wrong thread"); + resolved = _heap->evacuate_object(obj, thr); } if (atomic) {