From a62d67c08db0a33feb892a83023a20cb342425ba Mon Sep 17 00:00:00 2001 From: William Kemper Date: Thu, 9 Oct 2025 17:47:33 -0700 Subject: [PATCH 1/7] Do not unconditionally enqueue old objects during marking --- src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp index b176446452a19..7e7cd7d07e542 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp @@ -412,7 +412,7 @@ void ShenandoahBarrierSet::arraycopy_work(T* src, size_t count) { shenandoah_assert_forwarded_except(elem_ptr, obj, _heap->cancelled_gc()); ShenandoahHeap::atomic_update_oop(fwd, elem_ptr, o); } - if (ENQUEUE && !ctx->is_marked_strong_or_old(obj)) { + if (ENQUEUE && !ctx->is_marked_strong(obj)) { _satb_mark_queue_set.enqueue_known_active(queue, obj); } } From c0c4135cfc1e805dfd4f507ae06069cbadb51420 Mon Sep 17 00:00:00 2001 From: William Kemper Date: Fri, 10 Oct 2025 16:54:25 -0700 Subject: [PATCH 2/7] Simplify arraycopy barrier case for marking --- .../gc/shenandoah/shenandoahBarrierSet.inline.hpp | 15 +++------------ 1 file changed, 3 insertions(+), 12 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp index 7e7cd7d07e542..a3ec11e21ab11 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp @@ -426,23 +426,14 @@ void ShenandoahBarrierSet::arraycopy_barrier(T* src, T* dst, size_t count) { return; } - char gc_state = ShenandoahThreadLocalData::gc_state(Thread::current()); + const char gc_state = ShenandoahThreadLocalData::gc_state(Thread::current()); if ((gc_state & ShenandoahHeap::EVACUATION) != 0) { arraycopy_evacuation(src, count); } else if ((gc_state & ShenandoahHeap::UPDATE_REFS) != 0) { arraycopy_update(src, count); - } - - if (_heap->mode()->is_generational()) { - assert(ShenandoahSATBBarrier, "Generational mode assumes SATB mode"); - if ((gc_state & ShenandoahHeap::YOUNG_MARKING) != 0) { - arraycopy_marking(src, dst, count, false); - } - if ((gc_state & ShenandoahHeap::OLD_MARKING) != 0) { - arraycopy_marking(src, dst, count, true); - } } else if ((gc_state & ShenandoahHeap::MARKING) != 0) { - arraycopy_marking(src, dst, count, false); + const bool marking_old = gc_state & ShenandoahHeap::OLD_MARKING; + arraycopy_marking(src, dst, count, marking_old); } } From 0b76b05d403c532db55ce54037e9129903eade27 Mon Sep 17 00:00:00 2001 From: William Kemper Date: Tue, 14 Oct 2025 16:06:59 -0700 Subject: [PATCH 3/7] Why does this break? --- .../shenandoahBarrierSet.inline.hpp | 19 ++----------------- 1 file changed, 2 insertions(+), 17 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp index a3ec11e21ab11..c4820dc23c907 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp @@ -462,23 +462,8 @@ void ShenandoahBarrierSet::arraycopy_marking(T* src, T* dst, size_t count, bool * may hold references to young-gen */ if (ShenandoahSATBBarrier) { - T* array = dst; - HeapWord* array_addr = reinterpret_cast(array); - ShenandoahHeapRegion* r = _heap->heap_region_containing(array_addr); - if (is_old_marking) { - // Generational, old marking - assert(_heap->mode()->is_generational(), "Invariant"); - if (r->is_old() && (array_addr < _heap->marking_context()->top_at_mark_start(r))) { - arraycopy_work(array, count); - } - } else if (_heap->mode()->is_generational()) { - // Generational, young marking - if (r->is_old() || (array_addr < _heap->marking_context()->top_at_mark_start(r))) { - arraycopy_work(array, count); - } - } else if (array_addr < _heap->marking_context()->top_at_mark_start(r)) { - // Non-generational, marking - arraycopy_work(array, count); + if (!_heap->marking_context()->allocated_after_mark_start(reinterpret_cast(dst))) { + arraycopy_work(dst, count); } } } From 3086fd30b795149f7b664017c3a2337cdbc3d4e2 Mon Sep 17 00:00:00 2001 From: William Kemper Date: Thu, 6 Nov 2025 12:35:12 -0800 Subject: [PATCH 4/7] More simplification of arraycopy mark barrier --- .../gc/shenandoah/shenandoahBarrierSet.hpp | 2 +- .../shenandoahBarrierSet.inline.hpp | 26 ++----------------- 2 files changed, 3 insertions(+), 25 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp index 0d38cc757f44a..3944c9714166d 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp @@ -129,7 +129,7 @@ class ShenandoahBarrierSet: public BarrierSet { private: template - inline void arraycopy_marking(T* src, T* dst, size_t count, bool is_old_marking); + inline void arraycopy_marking(T* src, T* dst, size_t count); template inline void arraycopy_evacuation(T* src, size_t count); template diff --git a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp index c4820dc23c907..814aeddb7f473 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp @@ -432,35 +432,13 @@ void ShenandoahBarrierSet::arraycopy_barrier(T* src, T* dst, size_t count) { } else if ((gc_state & ShenandoahHeap::UPDATE_REFS) != 0) { arraycopy_update(src, count); } else if ((gc_state & ShenandoahHeap::MARKING) != 0) { - const bool marking_old = gc_state & ShenandoahHeap::OLD_MARKING; - arraycopy_marking(src, dst, count, marking_old); + arraycopy_marking(src, dst, count); } } template -void ShenandoahBarrierSet::arraycopy_marking(T* src, T* dst, size_t count, bool is_old_marking) { +void ShenandoahBarrierSet::arraycopy_marking(T* src, T* dst, size_t count) { assert(_heap->is_concurrent_mark_in_progress(), "only during marking"); - /* - * Note that an old-gen object is considered live if it is live at the start of OLD marking or if it is promoted - * following the start of OLD marking. - * - * 1. Every object promoted following the start of OLD marking will be above TAMS within its old-gen region - * 2. Every object live at the start of OLD marking will be referenced from a "root" or it will be referenced from - * another live OLD-gen object. With regards to old-gen, roots include stack locations and all of live young-gen. - * All root references to old-gen are identified during a bootstrap young collection. All references from other - * old-gen objects will be marked during the traversal of all old objects, or will be marked by the SATB barrier. - * - * During old-gen marking (which is interleaved with young-gen collections), call arraycopy_work() if: - * - * 1. The overwritten array resides in old-gen and it is below TAMS within its old-gen region - * 2. Do not call arraycopy_work for any array residing in young-gen because young-gen collection is idle at this time - * - * During young-gen marking, call arraycopy_work() if: - * - * 1. The overwritten array resides in young-gen and is below TAMS within its young-gen region - * 2. Additionally, if array resides in old-gen, regardless of its relationship to TAMS because this old-gen array - * may hold references to young-gen - */ if (ShenandoahSATBBarrier) { if (!_heap->marking_context()->allocated_after_mark_start(reinterpret_cast(dst))) { arraycopy_work(dst, count); From c53c4f23f4401785e1049494b6c4e4b92f9a5701 Mon Sep 17 00:00:00 2001 From: William Kemper Date: Thu, 6 Nov 2025 13:05:10 -0800 Subject: [PATCH 5/7] We can also filter out old when striclty marking young --- .../share/gc/shenandoah/shenandoahHeap.cpp | 4 +- .../shenandoah/shenandoahSATBMarkQueueSet.cpp | 40 ++++++++++++++----- .../shenandoah/shenandoahSATBMarkQueueSet.hpp | 20 ++++++++-- 3 files changed, 49 insertions(+), 15 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp index 38f055c34b666..719be6c243774 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp @@ -2029,8 +2029,8 @@ void ShenandoahHeap::propagate_gc_state_to_all_threads() { assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Must be at Shenandoah safepoint"); if (_gc_state_changed) { // If we are only marking old, we do not need to process young pointers - ShenandoahBarrierSet::satb_mark_queue_set().set_filter_out_young( - is_concurrent_old_mark_in_progress() && !is_concurrent_young_mark_in_progress() + ShenandoahBarrierSet::satb_mark_queue_set().set_filter_mode( + is_concurrent_young_mark_in_progress(), is_concurrent_old_mark_in_progress() ); ShenandoahGCStatePropagatorHandshakeClosure propagator(_gc_state.raw_value()); Threads::threads_do(&propagator); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.cpp b/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.cpp index c2ed575b43838..5d53d9cf5c30c 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.cpp @@ -28,18 +28,18 @@ #include "gc/shenandoah/shenandoahThreadLocalData.hpp" ShenandoahSATBMarkQueueSet::ShenandoahSATBMarkQueueSet(BufferNode::Allocator* allocator) : - SATBMarkQueueSet(allocator), _filter_out_young(false) + SATBMarkQueueSet(allocator), _filter_mode(FILTER_MARKED) {} SATBMarkQueue& ShenandoahSATBMarkQueueSet::satb_queue_for_thread(Thread* const t) const { return ShenandoahThreadLocalData::satb_mark_queue(t); } -class ShenandoahSATBMarkQueueFilterFn { +class ShenandoahSatbFilterOutMarked { ShenandoahHeap* const _heap; public: - explicit ShenandoahSATBMarkQueueFilterFn(ShenandoahHeap* heap) : _heap(heap) {} + explicit ShenandoahSatbFilterOutMarked(ShenandoahHeap* heap) : _heap(heap) {} // Return true if entry should be filtered out (removed), false if it should be retained. bool operator()(const void* entry) const { @@ -47,11 +47,11 @@ class ShenandoahSATBMarkQueueFilterFn { } }; -class ShenandoahSATBOldMarkQueueFilterFn { +class ShenandoahSatbFilterOutYoung { ShenandoahHeap* const _heap; public: - explicit ShenandoahSATBOldMarkQueueFilterFn(ShenandoahHeap* heap) : _heap(heap) {} + explicit ShenandoahSatbFilterOutYoung(ShenandoahHeap* heap) : _heap(heap) {} // Return true if entry should be filtered out (removed), false if it should be retained. bool operator()(const void* entry) const { @@ -61,11 +61,33 @@ class ShenandoahSATBOldMarkQueueFilterFn { } }; +class ShenandoahSatbFilterOutOld { + ShenandoahHeap* const _heap; + +public: + explicit ShenandoahSatbFilterOutOld(ShenandoahHeap* heap) : _heap(heap) {} + + // Return true if entry should be filtered out (removed), false if it should be retained. + bool operator()(const void* entry) const { + assert(!_heap->is_concurrent_old_mark_in_progress(), "Should only use this when old marking is not in progress"); + assert(_heap->is_concurrent_young_mark_in_progress(), "Should only use this when young marking is in progress"); + return !_heap->requires_marking(entry) || !_heap->is_in_young(entry); + } +}; + void ShenandoahSATBMarkQueueSet::filter(SATBMarkQueue& queue) { ShenandoahHeap* heap = ShenandoahHeap::heap(); - if (_filter_out_young) { - apply_filter(ShenandoahSATBOldMarkQueueFilterFn(heap), queue); - } else { - apply_filter(ShenandoahSATBMarkQueueFilterFn(heap), queue); + switch (_filter_mode) { + case FILTER_MARKED: + apply_filter(ShenandoahSatbFilterOutMarked(heap), queue); + break; + case FILTER_YOUNG: + apply_filter(ShenandoahSatbFilterOutYoung(heap), queue); + break; + case FILTER_OLD: + apply_filter(ShenandoahSatbFilterOutOld(heap), queue); + break; + default: + ShouldNotReachHere(); } } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.hpp b/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.hpp index dd4cdfebc176b..63317b8efacfe 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.hpp @@ -30,19 +30,31 @@ class ShenandoahSATBMarkQueueSet : public SATBMarkQueueSet { private: - bool _filter_out_young; + enum FilterMode { + FILTER_MARKED, + FILTER_YOUNG, + FILTER_OLD + }; + + FilterMode _filter_mode; public: explicit ShenandoahSATBMarkQueueSet(BufferNode::Allocator* allocator); SATBMarkQueue& satb_queue_for_thread(Thread* const t) const override; void filter(SATBMarkQueue& queue) override; - void set_filter_out_young(bool filter_out_young) { - _filter_out_young = filter_out_young; + void set_filter_mode(bool marking_young, bool marking_old) { + if (marking_young && !marking_old) { + _filter_mode = FILTER_OLD; + } else if (!marking_young && marking_old) { + _filter_mode = FILTER_YOUNG; + } else { + _filter_mode = FILTER_MARKED; + } } bool get_filter_out_young() const { - return _filter_out_young; + return _filter_mode == FILTER_YOUNG; } }; From ddd3d6d9aba32e75929ddcda8f9677fbc6841be3 Mon Sep 17 00:00:00 2001 From: William Kemper Date: Mon, 10 Nov 2025 15:53:03 -0800 Subject: [PATCH 6/7] SATB barrier for old must be independent of young collection gc state --- .../gc/shenandoah/shenandoahBarrierSet.hpp | 2 +- .../shenandoahBarrierSet.inline.hpp | 21 ++++++++++++------- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp index 3944c9714166d..2b5bc766a462a 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp @@ -129,7 +129,7 @@ class ShenandoahBarrierSet: public BarrierSet { private: template - inline void arraycopy_marking(T* src, T* dst, size_t count); + inline void arraycopy_marking(T* dst, size_t count); template inline void arraycopy_evacuation(T* src, size_t count); template diff --git a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp index 814aeddb7f473..adeea8ebf9613 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.inline.hpp @@ -387,13 +387,11 @@ template void ShenandoahBarrierSet::arraycopy_work(T* src, size_t count) { // Young cycles are allowed to run when old marking is in progress. When old marking is in progress, // this barrier will be called with ENQUEUE=true and HAS_FWD=false, even though the young generation - // may have forwarded objects. In this case, the `arraycopy_work` is first called with HAS_FWD=true and - // ENQUEUE=false. - assert(HAS_FWD == _heap->has_forwarded_objects() || _heap->is_concurrent_old_mark_in_progress(), - "Forwarded object status is sane"); + // may have forwarded objects. + assert(HAS_FWD == _heap->has_forwarded_objects() || _heap->is_concurrent_old_mark_in_progress(), "Forwarded object status is sane"); // This function cannot be called to handle marking and evacuation at the same time (they operate on // different sides of the copy). - assert((HAS_FWD || EVAC) != ENQUEUE, "Cannot evacuate and mark both sides of copy."); + static_assert((HAS_FWD || EVAC) != ENQUEUE, "Cannot evacuate and mark both sides of copy."); Thread* thread = Thread::current(); SATBMarkQueue& queue = ShenandoahThreadLocalData::satb_mark_queue(thread); @@ -427,17 +425,24 @@ void ShenandoahBarrierSet::arraycopy_barrier(T* src, T* dst, size_t count) { } const char gc_state = ShenandoahThreadLocalData::gc_state(Thread::current()); + if ((gc_state & ShenandoahHeap::MARKING) != 0) { + // If marking old or young, we must evaluate the SATB barrier. This will be the only + // action if we are not marking old. If we are marking old, we must still evaluate the + // load reference barrier for a young collection. + arraycopy_marking(dst, count); + } + if ((gc_state & ShenandoahHeap::EVACUATION) != 0) { + assert((gc_state & ShenandoahHeap::YOUNG_MARKING) == 0, "Cannot be marking young during evacuation"); arraycopy_evacuation(src, count); } else if ((gc_state & ShenandoahHeap::UPDATE_REFS) != 0) { + assert((gc_state & ShenandoahHeap::YOUNG_MARKING) == 0, "Cannot be marking young during update-refs"); arraycopy_update(src, count); - } else if ((gc_state & ShenandoahHeap::MARKING) != 0) { - arraycopy_marking(src, dst, count); } } template -void ShenandoahBarrierSet::arraycopy_marking(T* src, T* dst, size_t count) { +void ShenandoahBarrierSet::arraycopy_marking(T* dst, size_t count) { assert(_heap->is_concurrent_mark_in_progress(), "only during marking"); if (ShenandoahSATBBarrier) { if (!_heap->marking_context()->allocated_after_mark_start(reinterpret_cast(dst))) { From ba71462d095626805d85f84d5d206382829f781d Mon Sep 17 00:00:00 2001 From: William Kemper Date: Mon, 10 Nov 2025 16:30:31 -0800 Subject: [PATCH 7/7] Revert "We can also filter out old when striclty marking young" This reverts commit c53c4f23f4401785e1049494b6c4e4b92f9a5701. --- .../share/gc/shenandoah/shenandoahHeap.cpp | 4 +- .../shenandoah/shenandoahSATBMarkQueueSet.cpp | 40 +++++-------------- .../shenandoah/shenandoahSATBMarkQueueSet.hpp | 20 ++-------- 3 files changed, 15 insertions(+), 49 deletions(-) diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp index 719be6c243774..38f055c34b666 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp @@ -2029,8 +2029,8 @@ void ShenandoahHeap::propagate_gc_state_to_all_threads() { assert(ShenandoahSafepoint::is_at_shenandoah_safepoint(), "Must be at Shenandoah safepoint"); if (_gc_state_changed) { // If we are only marking old, we do not need to process young pointers - ShenandoahBarrierSet::satb_mark_queue_set().set_filter_mode( - is_concurrent_young_mark_in_progress(), is_concurrent_old_mark_in_progress() + ShenandoahBarrierSet::satb_mark_queue_set().set_filter_out_young( + is_concurrent_old_mark_in_progress() && !is_concurrent_young_mark_in_progress() ); ShenandoahGCStatePropagatorHandshakeClosure propagator(_gc_state.raw_value()); Threads::threads_do(&propagator); diff --git a/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.cpp b/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.cpp index 5d53d9cf5c30c..c2ed575b43838 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.cpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.cpp @@ -28,18 +28,18 @@ #include "gc/shenandoah/shenandoahThreadLocalData.hpp" ShenandoahSATBMarkQueueSet::ShenandoahSATBMarkQueueSet(BufferNode::Allocator* allocator) : - SATBMarkQueueSet(allocator), _filter_mode(FILTER_MARKED) + SATBMarkQueueSet(allocator), _filter_out_young(false) {} SATBMarkQueue& ShenandoahSATBMarkQueueSet::satb_queue_for_thread(Thread* const t) const { return ShenandoahThreadLocalData::satb_mark_queue(t); } -class ShenandoahSatbFilterOutMarked { +class ShenandoahSATBMarkQueueFilterFn { ShenandoahHeap* const _heap; public: - explicit ShenandoahSatbFilterOutMarked(ShenandoahHeap* heap) : _heap(heap) {} + explicit ShenandoahSATBMarkQueueFilterFn(ShenandoahHeap* heap) : _heap(heap) {} // Return true if entry should be filtered out (removed), false if it should be retained. bool operator()(const void* entry) const { @@ -47,11 +47,11 @@ class ShenandoahSatbFilterOutMarked { } }; -class ShenandoahSatbFilterOutYoung { +class ShenandoahSATBOldMarkQueueFilterFn { ShenandoahHeap* const _heap; public: - explicit ShenandoahSatbFilterOutYoung(ShenandoahHeap* heap) : _heap(heap) {} + explicit ShenandoahSATBOldMarkQueueFilterFn(ShenandoahHeap* heap) : _heap(heap) {} // Return true if entry should be filtered out (removed), false if it should be retained. bool operator()(const void* entry) const { @@ -61,33 +61,11 @@ class ShenandoahSatbFilterOutYoung { } }; -class ShenandoahSatbFilterOutOld { - ShenandoahHeap* const _heap; - -public: - explicit ShenandoahSatbFilterOutOld(ShenandoahHeap* heap) : _heap(heap) {} - - // Return true if entry should be filtered out (removed), false if it should be retained. - bool operator()(const void* entry) const { - assert(!_heap->is_concurrent_old_mark_in_progress(), "Should only use this when old marking is not in progress"); - assert(_heap->is_concurrent_young_mark_in_progress(), "Should only use this when young marking is in progress"); - return !_heap->requires_marking(entry) || !_heap->is_in_young(entry); - } -}; - void ShenandoahSATBMarkQueueSet::filter(SATBMarkQueue& queue) { ShenandoahHeap* heap = ShenandoahHeap::heap(); - switch (_filter_mode) { - case FILTER_MARKED: - apply_filter(ShenandoahSatbFilterOutMarked(heap), queue); - break; - case FILTER_YOUNG: - apply_filter(ShenandoahSatbFilterOutYoung(heap), queue); - break; - case FILTER_OLD: - apply_filter(ShenandoahSatbFilterOutOld(heap), queue); - break; - default: - ShouldNotReachHere(); + if (_filter_out_young) { + apply_filter(ShenandoahSATBOldMarkQueueFilterFn(heap), queue); + } else { + apply_filter(ShenandoahSATBMarkQueueFilterFn(heap), queue); } } diff --git a/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.hpp b/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.hpp index 63317b8efacfe..dd4cdfebc176b 100644 --- a/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.hpp +++ b/src/hotspot/share/gc/shenandoah/shenandoahSATBMarkQueueSet.hpp @@ -30,31 +30,19 @@ class ShenandoahSATBMarkQueueSet : public SATBMarkQueueSet { private: - enum FilterMode { - FILTER_MARKED, - FILTER_YOUNG, - FILTER_OLD - }; - - FilterMode _filter_mode; + bool _filter_out_young; public: explicit ShenandoahSATBMarkQueueSet(BufferNode::Allocator* allocator); SATBMarkQueue& satb_queue_for_thread(Thread* const t) const override; void filter(SATBMarkQueue& queue) override; - void set_filter_mode(bool marking_young, bool marking_old) { - if (marking_young && !marking_old) { - _filter_mode = FILTER_OLD; - } else if (!marking_young && marking_old) { - _filter_mode = FILTER_YOUNG; - } else { - _filter_mode = FILTER_MARKED; - } + void set_filter_out_young(bool filter_out_young) { + _filter_out_young = filter_out_young; } bool get_filter_out_young() const { - return _filter_mode == FILTER_YOUNG; + return _filter_out_young; } };