8369013: Shenandoah: passive mode should support enabling ShenandoahCardBarrier

Author: rgithubli

src/hotspot/share/gc/shenandoah/mode/shenandoahPassiveMode.cpp

@@ -48,11 +48,6 @@ void ShenandoahPassiveMode::initialize_flags() const {
   SHENANDOAH_ERGO_DISABLE_FLAG(ShenandoahCloneBarrier);
   SHENANDOAH_ERGO_DISABLE_FLAG(ShenandoahStackWatermarkBarrier);
   SHENANDOAH_ERGO_DISABLE_FLAG(ShenandoahCardBarrier);
-
-  // Final configuration checks
-  // Passive mode does not instantiate the machinery to support the card table.
-  // Exit if the flag has been explicitly set.
-  SHENANDOAH_CHECK_FLAG_UNSET(ShenandoahCardBarrier);
 }
 
 ShenandoahHeuristics* ShenandoahPassiveMode::initialize_heuristics(ShenandoahSpaceInfo* space_info) const {

src/hotspot/share/gc/shenandoah/shenandoahFullGC.cpp

@@ -1172,5 +1172,10 @@ ShenandoahGenerationalHeap::TransferResult ShenandoahFullGC::phase5_epilog() {
     result = ShenandoahGenerationalFullGC::balance_generations_after_rebuilding_free_set();
     ShenandoahGenerationalFullGC::rebuild_remembered_set(heap);
   }
+
+  // passive mode with ShenandoahCardBarrier turned on, clean the write table without swapping the tables
+  if (ShenandoahCardBarrier && !heap->mode()->is_generational()) {
+    heap->old_generation()->card_scan()->mark_write_table_as_clean();
+  }
   return result;
 }

src/hotspot/share/gc/shenandoah/shenandoahGenerationalHeap.hpp

@@ -44,13 +44,11 @@ class ShenandoahGenerationalHeap : public ShenandoahHeap {
   void initialize_heuristics() override;
 
   static ShenandoahGenerationalHeap* heap() {
-    shenandoah_assert_generational();
     CollectedHeap* heap = Universe::heap();
     return cast(heap);
   }
 
   static ShenandoahGenerationalHeap* cast(CollectedHeap* heap) {
-    shenandoah_assert_generational();
     return checked_cast<ShenandoahGenerationalHeap*>(heap);
   }
 

src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp

@@ -248,6 +248,19 @@ jint ShenandoahHeap::initialize() {
   // Now we know the number of regions and heap sizes, initialize the heuristics.
   initialize_heuristics();
 
+  // If ShenandoahCardBarrier is enabled but it's not generational mode
+  // it means we're under passive mode and we have to initialize old gen
+  // for the purpose of having card table.
+  if (ShenandoahCardBarrier && !(mode()->is_generational())) {
+    _generation_sizer.heap_size_changed(max_capacity());
+    size_t initial_capacity_young = _generation_sizer.max_young_size();
+    size_t max_capacity_young = _generation_sizer.max_young_size();
+    size_t initial_capacity_old = max_capacity() - max_capacity_young;
+    size_t max_capacity_old = max_capacity() - initial_capacity_young;
+
+    _old_generation = new ShenandoahOldGeneration(max_workers(), max_capacity_old);
+  }
+
   assert(_heap_region.byte_size() == heap_rs.size(), "Need to know reserved size for card table");
 
   //

src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp

@@ -530,7 +530,6 @@ class ShenandoahHeap : public CollectedHeap {
   }
 
   ShenandoahOldGeneration*   old_generation()    const {
-    assert(mode()->is_generational(), "Old generation requires generational mode");
     return _old_generation;
   }
 
@@ -564,6 +563,7 @@ class ShenandoahHeap : public CollectedHeap {
   ConcurrentGCTimer*           _gc_timer;
   // For exporting to SA
   int                          _log_min_obj_alignment_in_bytes;
+  ShenandoahGenerationSizer     _generation_sizer;
 public:
   ShenandoahMonitoringSupport* monitoring_support() const    { return _monitoring_support;    }
   GCMemoryManager* cycle_memory_manager()                    { return &_cycle_memory_manager; }

src/hotspot/share/gc/shenandoah/shenandoahScanRemembered.cpp

@@ -123,6 +123,18 @@ void ShenandoahDirectCardMarkRememberedSet::mark_read_table_as_clean() {
   log_develop_debug(gc, barrier)("Cleaned read_table from " PTR_FORMAT " to " PTR_FORMAT, p2i(&(read_table[0])), p2i(end_bp));
 }
 
+void ShenandoahDirectCardMarkRememberedSet::mark_write_table_as_clean() {
+  CardValue* write_table = _card_table->write_byte_map();
+  CardValue* bp = &(write_table)[0];
+  CardValue* end_bp = &(write_table)[_card_table->last_valid_index()];
+
+  while (bp <= end_bp) {
+    *bp++ = CardTable::clean_card_val();
+  }
+
+  log_develop_debug(gc, barrier)("Cleaned write_table from " PTR_FORMAT " to " PTR_FORMAT, p2i(&(write_table[0])), p2i(end_bp));
+}
+
 // No lock required because arguments align with card boundaries.
 void ShenandoahCardCluster::reset_object_range(HeapWord* from, HeapWord* to) {
   assert(((((unsigned long long) from) & (CardTable::card_size() - 1)) == 0) &&
@@ -330,6 +342,10 @@ void ShenandoahScanRemembered::mark_read_table_as_clean() {
   _rs->mark_read_table_as_clean();
 }
 
+void ShenandoahScanRemembered::mark_write_table_as_clean() {
+  _rs->mark_write_table_as_clean();
+}
+
 void ShenandoahScanRemembered::reset_object_range(HeapWord* from, HeapWord* to) {
   _scc->reset_object_range(from, to);
 }

src/hotspot/share/gc/shenandoah/shenandoahScanRemembered.hpp

@@ -244,6 +244,8 @@ class ShenandoahDirectCardMarkRememberedSet: public CHeapObj<mtGC> {
   // See comment in ShenandoahScanRemembered
   inline void mark_read_table_as_clean();
 
+  inline void mark_write_table_as_clean();
+
   // Merge any dirty values from write table into the read table, while leaving
   // the write table unchanged.
   void merge_write_table(HeapWord* start, size_t word_count);
@@ -769,6 +771,8 @@ class ShenandoahScanRemembered: public CHeapObj<mtGC> {
   // the "write" table.
   void mark_read_table_as_clean();
 
+  void mark_write_table_as_clean();
+
   // Swaps read and write card tables pointers in effect setting a clean card
   // table for the next GC cycle.
   void swap_card_tables() { _rs->swap_card_tables(); }

test/hotspot/jtreg/gc/shenandoah/options/TestWrongBarrierEnable.java

@@ -45,10 +45,9 @@ public static void main(String[] args) throws Exception {
         shouldPassAll("-XX:ShenandoahGCHeuristics=static",     concurrent);
         shouldPassAll("-XX:ShenandoahGCHeuristics=compact",    concurrent);
         shouldPassAll("-XX:ShenandoahGCHeuristics=aggressive", concurrent);
-        shouldPassAll("-XX:ShenandoahGCMode=passive",          concurrent);
+        shouldPassAll("-XX:ShenandoahGCMode=passive",          all);
         shouldPassAll("-XX:ShenandoahGCMode=generational",     all);
         shouldFailAll("-XX:ShenandoahGCMode=satb",             generational);
-        shouldFailAll("-XX:ShenandoahGCMode=passive",          generational);
     }
 
     private static void shouldFailAll(String h, String[] barriers) throws Exception {