8354358: ZGC: ZPartition::prime handle discontiguous reservations correctly

Reviewed-by: stefank, jsikstro, eosterlund

Author: xmas92

src/hotspot/share/gc/z/zPageAllocator.cpp

@@ -1003,36 +1003,43 @@ bool ZPartition::prime(ZWorkers* workers, size_t size) {
     return true;
   }
 
+  ZArray<ZVirtualMemory> vmems;
+
   // Claim virtual memory
-  const ZVirtualMemory vmem = claim_virtual(size);
+  const size_t claimed_size = claim_virtual(size, &vmems);
+
+  // The partition must have size available in virtual memory when priming.
+  assert(claimed_size == size, "must succeed %zx == %zx", claimed_size, size);
 
   // Increase capacity
-  increase_capacity(size);
+  increase_capacity(claimed_size);
 
-  // Claim the backing physical memory
-  claim_physical(vmem);
+  for (ZVirtualMemory vmem : vmems) {
+    // Claim the backing physical memory
+    claim_physical(vmem);
 
-  // Commit the claimed physical memory
-  const size_t committed = commit_physical(vmem);
+    // Commit the claimed physical memory
+    const size_t committed = commit_physical(vmem);
 
-  if (committed != vmem.size()) {
-    // This is a failure state. We do not cleanup the maybe partially committed memory.
-    return false;
-  }
+    if (committed != vmem.size()) {
+      // This is a failure state. We do not cleanup the maybe partially committed memory.
+      return false;
+    }
 
-  map_virtual(vmem);
+    map_virtual(vmem);
 
-  check_numa_mismatch(vmem, _numa_id);
+    check_numa_mismatch(vmem, _numa_id);
 
-  if (AlwaysPreTouch) {
-    // Pre-touch memory
-    ZPreTouchTask task(vmem.start(), vmem.end());
-    workers->run_all(&task);
-  }
+    if (AlwaysPreTouch) {
+      // Pre-touch memory
+      ZPreTouchTask task(vmem.start(), vmem.end());
+      workers->run_all(&task);
+    }
 
-  // We don't have to take a lock here as no other threads will access the cache
-  // until we're finished
-  _cache.insert(vmem);
+    // We don't have to take a lock here as no other threads will access the cache
+    // until we're finished
+    _cache.insert(vmem);
+  }
 
   return true;
 }

test/hotspot/jtreg/gc/z/TestZForceDiscontiguousHeapReservations.java

@@ -39,12 +39,10 @@ public class TestZForceDiscontiguousHeapReservations {
     private static void testValue(int n) throws Exception  {
         /**
          *  Xmx is picked so that it is divisible by 'ZForceDiscontiguousHeapReservations * ZGranuleSize'
-         *  Xms is picked so that it is less than '16 * Xmx / ZForceDiscontiguousHeapReservations' as ZGC
-         *   cannot currently handle a discontiguous heap with an initial size larger than the individual
-         *   reservations.
+         *  Xms is picked to be the same as Xmx
          */
         final int XmxInM = 2000;
-        final int XmsInM = Math.min(16 * XmxInM / (n + 1), XmxInM);
+        final int XmsInM = XmxInM;
         OutputAnalyzer oa = ProcessTools.executeTestJava(
             "-XX:+UseZGC",
             "-Xms" + XmsInM + "M",

test/hotspot/jtreg/gc/z/TestZNMT.java

@@ -63,9 +63,7 @@ public static void main(String[] args) throws Exception {
     private static void testValue(int zForceDiscontiguousHeapReservations) throws Exception  {
         /**
          *  Xmx is picked so that it is divisible by 'ZForceDiscontiguousHeapReservations * ZGranuleSize'
-         *  Xms is picked so that it is less than '16 * Xmx / ZForceDiscontiguousHeapReservations' as ZGC
-         *   cannot currently handle a discontiguous heap with an initial size larger than the individual
-         *   reservations.
+         *  Xms is picked so that it is less than '16 * Xmx / ZForceDiscontiguousHeapReservations'
          */
         final int XmsInM = Math.min(16 * XmxInM / (zForceDiscontiguousHeapReservations + 1), XmxInM);
         OutputAnalyzer oa = ProcessTools.executeTestJava(