* when aborting refinement during full collection, the global card ta…

…ble and the per-thread card table might not be in sync. Roll forward during abort of the refinement in these situations.

* additional verification
* added some missing ResourceMarks in asserts
* added variant of ArrayJuggle2 that crashes fairly quickly without these changes

src/hotspot/share/gc/g1/g1BarrierSet.cpp

@@ -73,6 +73,16 @@ void G1BarrierSet::swap_global_card_table() {
   _refinement_table = temp;
 }
 
+void G1BarrierSet::update_card_table_base(Thread* thread) {
+#ifdef ASSERT
+  {
+    ResourceMark rm;
+    assert(thread->is_Java_thread(), "may only update card table base of JavaThreads, not %s", thread->name());
+  }
+#endif
+  G1ThreadLocalData::set_byte_map_base(thread, _card_table->byte_map_base());
+}
+
 template <class T> void
 G1BarrierSet::write_ref_array_pre_work(T* dst, size_t count) {
   G1SATBMarkQueueSet& queue_set = G1BarrierSet::satb_mark_queue_set();
@@ -161,7 +171,8 @@ void G1BarrierSet::on_thread_attach(Thread* thread) {
   satbq.set_active(_satb_mark_queue_set.is_active());
 
   if (thread->is_Java_thread()) {
-    G1ThreadLocalData::set_byte_map_base(thread, G1CollectedHeap::heap()->card_table_base());
+    assert(Threads_lock->is_locked(), "must be, synchronization with refinement.");
+    update_card_table_base(thread);
   }
 }
 

src/hotspot/share/gc/g1/g1BarrierSet.hpp

@@ -31,6 +31,7 @@
 #include "gc/shared/bufferNode.hpp"
 
 class G1CardTable;
+class Thread;
 
 // This barrier set is specialized to manage two card tables:
 // * one the mutator is currently working on ("card table")
@@ -81,6 +82,9 @@ class G1BarrierSet: public CardTableBarrierSet {
   // Swap the global card table references, without synchronization.
   void swap_global_card_table();
 
+  // Update the given thread's card table (byte map) base to the current card table's.
+  void update_card_table_base(Thread* thread);
+
   virtual bool card_mark_must_follow_store() const {
     return true;
   }

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -108,6 +108,7 @@
 #include "runtime/init.hpp"
 #include "runtime/java.hpp"
 #include "runtime/orderAccess.hpp"
+#include "runtime/threads.hpp"
 #include "runtime/threadSMR.hpp"
 #include "runtime/vmThread.hpp"
 #include "utilities/align.hpp"
@@ -800,6 +801,20 @@ void G1CollectedHeap::prepare_for_mutator_after_full_collection() {
 void G1CollectedHeap::abort_refinement() {
   G1ConcurrentRefineSweepState& sweep_state = concurrent_refine()->sweep_state();
   if (sweep_state.is_in_progress()) {
+
+    if (!sweep_state.are_java_threads_synched()) {
+      // Synchronize Java threads with global card table that has already been swapped.
+      class SwapThreadCardTableClosure : public ThreadClosure {
+      public:
+
+        virtual void do_thread(Thread* t) {
+          G1BarrierSet* bs = G1BarrierSet::g1_barrier_set();
+          bs->update_card_table_base(t);
+        }
+      } cl;
+      Threads::java_threads_do(&cl);
+    }
+
     // Record any available refinement statistics.
     policy()->record_refinement_stats(sweep_state.stats());
     sweep_state.complete_work(false /* concurrent */, false /* print_log */);
@@ -816,6 +831,7 @@ void G1CollectedHeap::verify_after_full_collection() {
   }
   _hrm.verify_optional();
   _verifier->verify_region_sets_optional();
+  _verifier->verify_card_tables_clean(true /* both_card_tables */);
   _verifier->verify_after_gc();
   _verifier->verify_bitmap_clear(false /* above_tams_only */);
 

src/hotspot/share/gc/g1/g1ConcurrentRefine.cpp

@@ -217,9 +217,9 @@ bool G1ConcurrentRefineSweepState::swap_java_threads_ct() {
   public:
     G1SwapThreadCardTableClosure() : HandshakeClosure("G1 Swap JT card table") { }
 
-    virtual void do_thread(Thread* t) {
+    virtual void do_thread(Thread* thread) {
       G1BarrierSet* bs = G1BarrierSet::g1_barrier_set();
-      G1ThreadLocalData::set_byte_map_base(t, bs->card_table()->byte_map_base());
+      bs->update_card_table_base(thread);
     }
   } cl;
   Handshake::execute(&cl);
@@ -374,6 +374,10 @@ bool G1ConcurrentRefineSweepState::is_in_progress() const {
   return _state != State::Idle;
 }
 
+bool G1ConcurrentRefineSweepState::are_java_threads_synched() const {
+  return _state > State::SwapJavaThreadsCT || !is_in_progress();
+}
+
 uint64_t G1ConcurrentRefine::adjust_threads_period_ms() const {
   // Instead of a fixed value, this could be a command line option.  But then
   // we might also want to allow configuration of adjust_threads_wait_ms().

src/hotspot/share/gc/g1/g1ConcurrentRefine.hpp

@@ -183,6 +183,7 @@ class G1ConcurrentRefineSweepState {
   void add_yield_duration(jlong duration);
 
   bool is_in_progress() const;
+  bool are_java_threads_synched() const;
 };
 
 // Controls concurrent refinement.

src/hotspot/share/gc/g1/g1HeapVerifier.cpp

@@ -42,6 +42,7 @@
 #include "oops/compressedOops.inline.hpp"
 #include "oops/oop.inline.hpp"
 #include "runtime/handles.inline.hpp"
+#include "runtime/threads.hpp"
 
 int G1HeapVerifier::_enabled_verification_types = G1HeapVerifier::G1VerifyAll;
 
@@ -527,6 +528,7 @@ void G1HeapVerifier::verify_before_gc() {
 
 void G1HeapVerifier::verify_after_gc() {
   verify(VerifyOption::G1UseConcMarking, "After GC");
+  verify_card_tables_in_sync();
 }
 
 void G1HeapVerifier::verify_bitmap_clear(bool from_tams) {
@@ -578,23 +580,25 @@ void G1HeapVerifier::verify_card_table_cleanup() {
   }
 }
 
-class G1VerifyRefinementTableClean: public G1HeapRegionClosure {
+class G1VerifyCardTablesClean: public G1HeapRegionClosure {
   G1HeapVerifier* _verifier;
+  bool _both_card_tables;
 
 public:
-  G1VerifyRefinementTableClean(G1HeapVerifier* verifier)
-    : _verifier(verifier) { }
+  G1VerifyCardTablesClean(G1HeapVerifier* verifier, bool both_card_tables = true)
+    : _verifier(verifier), _both_card_tables(both_card_tables) { }
 
   virtual bool do_heap_region(G1HeapRegion* r) {
-    G1CardTable* ct = G1CollectedHeap::heap()->refinement_table();
-    MemRegion mr(r->bottom(), r->end());
-    ct->verify_region(mr, G1CardTable::clean_card_val(), true); // Must be all Clean from bottom -> end.
+    _verifier->verify_rt_clean_region(r);     // Must be all Clean from bottom -> end.
+    if (_both_card_tables) {
+      _verifier->verify_ct_clean_region(r);
+    }
     return false;
   }
 };
 
-void G1HeapVerifier::verify_refinement_table_clean() {
-  G1VerifyRefinementTableClean cl(this);
+void G1HeapVerifier::verify_card_tables_clean(bool both_card_tables) {
+  G1VerifyCardTablesClean cl(this, both_card_tables);
   _g1h->heap_region_iterate(&cl);
 }
 
@@ -630,6 +634,40 @@ void G1HeapVerifier::verify_rt_clean_region(G1HeapRegion* hr) {
 }
 
 #ifndef PRODUCT
+
+void G1HeapVerifier::verify_card_tables_in_sync() {
+
+    // Non-Java thread card tables must be null.
+    class AssertCardTableBaseNull : public ThreadClosure {
+    public:
+
+      void do_thread(Thread* thread) {
+        ResourceMark rm;
+        assert(G1ThreadLocalData::get_byte_map_base(thread) == nullptr, "thread " PTR_FORMAT " (%s) has non-null card table base",
+               p2i(thread), thread->name());
+      }
+    } check_null_cl;
+
+    Threads::non_java_threads_do(&check_null_cl);
+
+    // Java thread card tables must be the same as the global card table.
+    class AssertSameCardTableClosure : public ThreadClosure {
+    public:
+
+      void do_thread(Thread* thread) {
+        G1CardTable::CardValue* global_ct_base = G1CollectedHeap::heap()->card_table_base();
+        G1CardTable::CardValue* cur_ct_base = G1ThreadLocalData::get_byte_map_base(thread);
+
+        ResourceMark rm;
+        assert(cur_ct_base == global_ct_base,
+               "thread " PTR_FORMAT " (%s) has wrong card table base, should be " PTR_FORMAT " is " PTR_FORMAT,
+               p2i(thread), thread->name(), p2i(global_ct_base), p2i(cur_ct_base));
+      }
+    } check_same_cl;
+
+    Threads::java_threads_do(&check_same_cl);
+}
+
 class G1CheckRegionAttrTableClosure : public G1HeapRegionClosure {
 private:
   bool _failures;

src/hotspot/share/gc/g1/g1HeapVerifier.hpp

@@ -79,12 +79,15 @@ class G1HeapVerifier : public CHeapObj<mtGC> {
   bool check_region_attr_table() PRODUCT_RETURN_( return true; );
 
   void verify_card_table_cleanup();
-  void verify_refinement_table_clean();
+  void verify_card_tables_clean(bool both_card_tables);
 
   void verify_ct_clean_region(G1HeapRegion* hr);
   void verify_rt_dirty_to_dummy_top(G1HeapRegion* hr);
   void verify_rt_clean_from_top(G1HeapRegion* hr);
   void verify_rt_clean_region(G1HeapRegion* hr);
+
+  // Verify that the global card table and the thread's card tables are in sync.
+  void verify_card_tables_in_sync() PRODUCT_RETURN;
 };
 
 #endif // SHARE_GC_G1_G1HEAPVERIFIER_HPP

src/hotspot/share/gc/g1/g1RemSet.cpp

@@ -1288,7 +1288,7 @@ void G1RemSet::merge_heap_roots(bool initial_evacuation) {
   }
 
   if (VerifyDuringGC && initial_evacuation) {
-    g1h->verifier()->verify_refinement_table_clean();
+    g1h->verifier()->verify_card_tables_clean(false /* both_card_tables */);
   }
 }
 

src/hotspot/share/gc/g1/g1ThreadLocalData.hpp

@@ -90,7 +90,7 @@ class G1ThreadLocalData {
     data(thread)->_byte_map_base = new_byte_map_base;
   }
 
-#ifdef ASSERT
+#ifndef PRODUCT
   static G1CardTable::CardValue* get_byte_map_base(Thread* thread) {
     return data(thread)->_byte_map_base;
   }

src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp

@@ -839,17 +839,6 @@ class G1PostEvacuateCollectionSetCleanupTask2::ResizeTLABsAndSwapCardTableTask :
     : G1AbstractSubTask(G1GCPhaseTimes::ResizeThreadLABs), _claimer(ThreadsPerWorker)
   {
     G1BarrierSet::g1_barrier_set()->swap_global_card_table();
-
-#ifdef ASSERT
-    class AssertCardTableBaseNull : public ThreadClosure {
-    public:
-
-      void do_thread(Thread* thread) {
-        assert(G1ThreadLocalData::get_byte_map_base(thread) == nullptr, "thread " PTR_FORMAT " (%s) has non-null card table base", p2i(thread), thread->name());
-      }
-    } assert_cl;
-    Threads::non_java_threads_do(&assert_cl);
-#endif
   }
 
   void do_work(uint worker_id) override {
@@ -862,9 +851,7 @@ class G1PostEvacuateCollectionSetCleanupTask2::ResizeTLABsAndSwapCardTableTask :
           static_cast<JavaThread*>(thread)->tlab().resize();
         }
 
-        // The global card table references have already been swapped.
-        G1CardTable::CardValue* new_card_table_base = G1CollectedHeap::heap()->card_table_base();
-        G1ThreadLocalData::set_byte_map_base(thread, new_card_table_base);
+        G1BarrierSet::g1_barrier_set()->update_card_table_base(thread);
       }
     } resize_and_swap_cl;
 

test/hotspot/jtreg/vmTestbase/gc/ArrayJuggle/Juggle2.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2025, Oracle and/or its affiliates. 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
@@ -30,6 +30,11 @@
 /* @test @key stress randomness @library /vmTestbase /test/lib @run main/othervm -Xlog:gc=debug:gc.log gc.ArrayJuggle.Juggle2 */
 /* @test @key stress randomness @library /vmTestbase /test/lib @run main/othervm -Xlog:gc=debug:gc.log gc.ArrayJuggle.Juggle2 -tg */
 
+/*
+ * The next test stresses the interaction between (mostly) full garbage collections and refinement.
+ */
+/* @test @key stress randomness @library /vmTestbase /test/lib @run main/othervm -XX:-G1UseAdaptiveIHOP -XX:InitiatingHeapOccupancyPercent=0 -XX:G1HeapRegionSize=1m -XX:G1RSetUpdatingPauseTimePercent=0 -XX:G1UpdateBufferSize=1 -XX:+UnlockDiagnosticVMOptions -XX:+VerifyAfterGC -Xlog:gc=debug,gc+refine=debug:gc.log gc.ArrayJuggle.Juggle2 -tg */
+
 package gc.ArrayJuggle;
 
 import nsk.share.test.*;