8347804: GenShen: Crash with small GCCardSizeInBytes and small Java heap

Reviewed-by: wkemper

Author: kdnilsen

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

@@ -29,6 +29,7 @@
 #include "gc/shared/tlab_globals.hpp"
 #include "gc/shared/workerPolicy.hpp"
 #include "gc/shenandoah/shenandoahArguments.hpp"
+#include "gc/shenandoah/shenandoahCardTable.hpp"
 #include "gc/shenandoah/shenandoahCollectorPolicy.hpp"
 #include "gc/shenandoah/shenandoahGenerationalHeap.hpp"
 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
@@ -187,6 +188,11 @@ void ShenandoahArguments::initialize() {
     FLAG_SET_DEFAULT(TLABAllocationWeight, 90);
   }
 
+  if (GCCardSizeInBytes < ShenandoahMinCardSizeInBytes) {
+    vm_exit_during_initialization(
+      err_msg("GCCardSizeInBytes ( %u ) must be >= %u\n", GCCardSizeInBytes, (unsigned int) ShenandoahMinCardSizeInBytes));
+  }
+
   FullGCForwarding::initialize_flags(MaxHeapSize);
 }
 

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

@@ -30,6 +30,8 @@
 #include "oops/oopsHierarchy.hpp"
 #include "utilities/macros.hpp"
 
+#define ShenandoahMinCardSizeInBytes 128
+
 class ShenandoahCardTable: public CardTable {
   friend class VMStructs;
 

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

@@ -727,7 +727,6 @@ size_t ShenandoahRegionChunkIterator::calc_regular_group_size() {
   // half of the remaining heap, the third processes half of what remains and so on.  The smallest chunk size
   // is represented by _smallest_chunk_size_words.  We do not divide work any smaller than this.
   //
-
   size_t group_size = _heap->num_regions() / 2;
   return group_size;
 }
@@ -773,6 +772,7 @@ size_t ShenandoahRegionChunkIterator::calc_num_groups() {
     // Any remaining regions will be treated as if they are part of the most recently created group.  This group will
     // have more than _regular_group_size chunks within it.
   }
+  assert (num_groups <= _maximum_groups, "Cannot have more than %zu groups", _maximum_groups);
   return num_groups;
 }
 
@@ -784,21 +784,31 @@ size_t ShenandoahRegionChunkIterator::calc_total_chunks() {
   size_t current_group_span = _first_group_chunk_size_b4_rebalance * _regular_group_size;
   size_t smallest_group_span = smallest_chunk_size_words() * _regular_group_size;
 
-  // The first group gets special handling because the first chunk size can be no larger than _largest_chunk_size_words
+  // The first group gets special handling because the first chunk size can be no larger than _maximum_chunk_size_words
   if (region_size_words > _maximum_chunk_size_words) {
     // In the case that we shrink the first group's chunk size, certain other groups will also be subsumed within the first group
     size_t effective_chunk_size = _first_group_chunk_size_b4_rebalance;
+    uint coalesced_groups = 0;
     while (effective_chunk_size >= _maximum_chunk_size_words) {
+      // Each iteration of this loop subsumes one original group into a new rebalanced initial group.
       num_chunks += current_group_span / _maximum_chunk_size_words;
       unspanned_heap_size -= current_group_span;
       effective_chunk_size /= 2;
       current_group_span /= 2;
+      coalesced_groups++;
     }
+    assert(effective_chunk_size * 2 == _maximum_chunk_size_words,
+           "We assume _first_group_chunk_size_b4_rebalance is _maximum_chunk_size_words * a power of two");
+    _largest_chunk_size_words = _maximum_chunk_size_words;
+    _adjusted_num_groups = _num_groups - (coalesced_groups - 1);
   } else {
     num_chunks = _regular_group_size;
     unspanned_heap_size -= current_group_span;
+    _largest_chunk_size_words = current_group_span / num_chunks;
+    _adjusted_num_groups = _num_groups;
     current_group_span /= 2;
   }
+
   size_t spanned_groups = 1;
   while (unspanned_heap_size > 0) {
     if (current_group_span <= unspanned_heap_size) {
@@ -856,11 +866,12 @@ ShenandoahRegionChunkIterator::ShenandoahRegionChunkIterator(ShenandoahHeap* hea
   size_t expected_chunk_size_words = _clusters_in_smallest_chunk * CardTable::card_size_in_words() * ShenandoahCardCluster::CardsPerCluster;
   assert(smallest_chunk_size_words() == expected_chunk_size_words, "_smallest_chunk_size (%zu) is not valid because it does not equal (%zu)",
          smallest_chunk_size_words(), expected_chunk_size_words);
-#endif
   assert(_num_groups <= _maximum_groups,
          "The number of remembered set scanning groups must be less than or equal to maximum groups");
-  assert(smallest_chunk_size_words() << (_maximum_groups - 1) == _maximum_chunk_size_words,
-         "Maximum number of groups needs to span maximum chunk size to smallest chunk size");
+  assert(smallest_chunk_size_words() << (_adjusted_num_groups - 1) == _largest_chunk_size_words,
+         "The number of groups (%zu) needs to span smallest chunk size (%zu) to largest chunk size (%zu)",
+         _adjusted_num_groups, smallest_chunk_size_words(), _largest_chunk_size_words);
+#endif
 
   size_t words_in_region = ShenandoahHeapRegion::region_size_words();
   _region_index[0] = 0;
@@ -883,7 +894,7 @@ ShenandoahRegionChunkIterator::ShenandoahRegionChunkIterator(ShenandoahHeap* hea
   }
 
   size_t previous_group_span = _group_entries[0] * _group_chunk_size[0];
-  for (size_t i = 1; i < _num_groups; i++) {
+  for (size_t i = 1; i < _adjusted_num_groups; i++) {
     _group_chunk_size[i] = _group_chunk_size[i-1] / 2;
     size_t chunks_in_group = _regular_group_size;
     size_t this_group_span = _group_chunk_size[i] * chunks_in_group;
@@ -893,19 +904,19 @@ ShenandoahRegionChunkIterator::ShenandoahRegionChunkIterator(ShenandoahHeap* hea
     _group_entries[i] = _group_entries[i-1] + _regular_group_size;
     previous_group_span = total_span_of_groups;
   }
-  if (_group_entries[_num_groups-1] < _total_chunks) {
-    assert((_total_chunks - _group_entries[_num_groups-1]) * _group_chunk_size[_num_groups-1] + previous_group_span ==
+  if (_group_entries[_adjusted_num_groups-1] < _total_chunks) {
+    assert((_total_chunks - _group_entries[_adjusted_num_groups-1]) * _group_chunk_size[_adjusted_num_groups-1] + previous_group_span ==
            heap->num_regions() * words_in_region, "Total region chunks (%zu"
            ") do not span total heap regions (%zu)", _total_chunks, _heap->num_regions());
-    previous_group_span += (_total_chunks - _group_entries[_num_groups-1]) * _group_chunk_size[_num_groups-1];
-    _group_entries[_num_groups-1] = _total_chunks;
+    previous_group_span += (_total_chunks - _group_entries[_adjusted_num_groups-1]) * _group_chunk_size[_adjusted_num_groups-1];
+    _group_entries[_adjusted_num_groups-1] = _total_chunks;
   }
   assert(previous_group_span == heap->num_regions() * words_in_region, "Total region chunks (%zu"
          ") do not span total heap regions (%zu): %zu does not equal %zu",
          _total_chunks, _heap->num_regions(), previous_group_span, heap->num_regions() * words_in_region);
 
   // Not necessary, but keeps things tidy
-  for (size_t i = _num_groups; i < _maximum_groups; i++) {
+  for (size_t i = _adjusted_num_groups; i < _maximum_groups; i++) {
     _region_index[i] = 0;
     _group_offset[i] = 0;
     _group_entries[i] = _group_entries[i-1];

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

@@ -196,11 +196,14 @@ class ShenandoahDirectCardMarkRememberedSet: public CHeapObj<mtGC> {
 
   // Use symbolic constants defined in cardTable.hpp
   //  CardTable::card_shift = 9;
-  //  CardTable::card_size = 512;
-  //  CardTable::card_size_in_words = 64;
+  //  CardTable::card_size = 512;  (default value 512, a power of 2 >= 128)
+  //  CardTable::card_size_in_words = 64; (default value 64, a power of 2 >= 16)
   //  CardTable::clean_card_val()
   //  CardTable::dirty_card_val()
 
+  // See shenandoahCardTable.hpp
+  //  ShenandoahMinCardSizeInBytes 128
+
   const size_t LogCardValsPerIntPtr;    // the number of card values (entries) in an intptr_t
   const size_t LogCardSizeInWords;      // the size of a card in heap word units
 
@@ -888,14 +891,14 @@ class ShenandoahRegionChunkIterator : public StackObj {
   // The largest chunk size is 4 MiB, measured in words.  Otherwise, remembered set scanning may become too unbalanced.
   // If the largest chunk size is too small, there is too much overhead sifting out assignments to individual worker threads.
   static const size_t _maximum_chunk_size_words = (4 * 1024 * 1024) / HeapWordSize;
-
   static const size_t _clusters_in_smallest_chunk = 4;
 
+  size_t _largest_chunk_size_words;
+
   // smallest_chunk_size is 4 clusters.  Each cluster spans 128 KiB.
   // This is computed from CardTable::card_size_in_words() * ShenandoahCardCluster::CardsPerCluster;
   static size_t smallest_chunk_size_words() {
-      return _clusters_in_smallest_chunk * CardTable::card_size_in_words() *
-             ShenandoahCardCluster::CardsPerCluster;
+      return _clusters_in_smallest_chunk * CardTable::card_size_in_words() * ShenandoahCardCluster::CardsPerCluster;
   }
 
   // The total remembered set scanning effort is divided into chunks of work that are assigned to individual worker tasks.
@@ -910,19 +913,30 @@ class ShenandoahRegionChunkIterator : public StackObj {
   // The first group "effectively" processes chunks of size 1 MiB (or smaller for smaller region sizes).
   // The last group processes chunks of size 128 KiB.  There are four groups total.
 
-  // group[0] is 4 MiB chunk size (_maximum_chunk_size_words)
-  // group[1] is 2 MiB chunk size
-  // group[2] is 1 MiB chunk size
-  // group[3] is 512 KiB chunk size
-  // group[4] is 256 KiB chunk size
-  // group[5] is 128 Kib shunk size (_smallest_chunk_size_words = 4 * 64 * 64
-  static const size_t _maximum_groups = 6;
+  // group[ 0] is 4 MiB chunk size (_maximum_chunk_size_words)
+  // group[ 1] is 2 MiB chunk size
+  // group[ 2] is 1 MiB chunk size
+  // group[ 3] is 512 KiB chunk size
+  // group[ 4] is 256 KiB chunk size
+  // group[ 5] is 128 KiB chunk size
+  // group[ 6] is  64 KiB chunk size
+  // group[ 7] is  32 KiB chunk size
+  // group[ 8] is  16 KiB chunk size
+  // group[ 9] is   8 KiB chunk size
+  // group[10] is   4 KiB chunk size
+  //   Note: 4 KiB is smallest possible chunk_size, computed from:
+  //         _clusters_in_smallest_chunk * MinimumCardSizeInWords * ShenandoahCardCluster::CardsPerCluster, which is
+  //         4 * 16 * 64 = 4096
+
+  // We set aside arrays to represent the maximum number of groups that may be required for any heap configuration
+  static const size_t _maximum_groups = 11;
 
   const ShenandoahHeap* _heap;
 
   const size_t _regular_group_size;                        // Number of chunks in each group
   const size_t _first_group_chunk_size_b4_rebalance;
   const size_t _num_groups;                        // Number of groups in this configuration
+  size_t _adjusted_num_groups;                     // Rebalancing may coalesce groups
   const size_t _total_chunks;
 
   shenandoah_padding(0);

test/hotspot/jtreg/gc/shenandoah/compiler/TestClone.java

@@ -232,6 +232,32 @@
  *                   TestClone
  */
 
+/*
+ * @test id=generational-small-card-size
+ * @summary Test clone barriers work correctly
+ * @requires vm.gc.Shenandoah
+ *
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+UnlockExperimentalVMOptions -Xms1g -Xmx1g
+ *                   -XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational -XX:GCCardSizeInBytes=128
+ *                   TestClone
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+UnlockExperimentalVMOptions -Xms1g -Xmx1g
+ *                   -XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational -XX:GCCardSizeInBytes=128
+ *                   -Xint
+ *                   TestClone
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+UnlockExperimentalVMOptions -Xms1g -Xmx1g
+ *                   -XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational -XX:GCCardSizeInBytes=128
+ *                   -XX:-TieredCompilation
+ *                   TestClone
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+UnlockExperimentalVMOptions -Xms1g -Xmx1g
+ *                   -XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational -XX:GCCardSizeInBytes=128
+ *                   -XX:TieredStopAtLevel=1
+ *                   TestClone
+ * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+UnlockExperimentalVMOptions -Xms1g -Xmx1g
+ *                   -XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational -XX:GCCardSizeInBytes=128
+ *                   -XX:TieredStopAtLevel=4
+ *                   TestClone
+ */
+
 /*
  * @test id=generational-verify
  * @summary Test clone barriers work correctly