Map unmapped harvested memory before returning it to cache.

Author: jsikstro

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

@@ -83,42 +83,42 @@ class ZMemory : public CHeapObj<mtGC> {
 ZMemory* ZMemoryManager::create(zoffset start, size_t size) {
   ZMemory* const area = new ZMemory(start, size);
   if (_callbacks._create != nullptr) {
-    _callbacks._create(area);
+    _callbacks._create(area->range());
   }
   return area;
 }
 
 void ZMemoryManager::destroy(ZMemory* area) {
   if (_callbacks._destroy != nullptr) {
-    _callbacks._destroy(area);
+    _callbacks._destroy(area->range());
   }
   delete area;
 }
 
 void ZMemoryManager::shrink_from_front(ZMemory* area, size_t size) {
   if (_callbacks._shrink_from_front != nullptr) {
-    _callbacks._shrink_from_front(area, size);
+    _callbacks._shrink_from_front(area->range(), size);
   }
   area->shrink_from_front(size);
 }
 
 void ZMemoryManager::shrink_from_back(ZMemory* area, size_t size) {
   if (_callbacks._shrink_from_back != nullptr) {
-    _callbacks._shrink_from_back(area, size);
+    _callbacks._shrink_from_back(area->range(), size);
   }
   area->shrink_from_back(size);
 }
 
 void ZMemoryManager::grow_from_front(ZMemory* area, size_t size) {
   if (_callbacks._grow_from_front != nullptr) {
-    _callbacks._grow_from_front(area, size);
+    _callbacks._grow_from_front(area->range(), size);
   }
   area->grow_from_front(size);
 }
 
 void ZMemoryManager::grow_from_back(ZMemory* area, size_t size) {
   if (_callbacks._grow_from_back != nullptr) {
-    _callbacks._grow_from_back(area, size);
+    _callbacks._grow_from_back(area->range(), size);
   }
   area->grow_from_back(size);
 }

src/hotspot/share/gc/z/zMemory.hpp

@@ -84,11 +84,11 @@ class ZMemoryManager {
   Callbacks      _callbacks;
 
   ZMemory* create(zoffset start, size_t size);
-  void destroy(const ZMemoryRange& range);
-  void shrink_from_front(const ZMemoryRange& range, size_t size);
-  void shrink_from_back(const ZMemoryRange& range, size_t size);
-  void grow_from_front(const ZMemoryRange& range, size_t size);
-  void grow_from_back(const ZMemoryRange& range, size_t size);
+  void destroy(ZMemory* area);
+  void shrink_from_front(ZMemory* area, size_t size);
+  void shrink_from_back(ZMemory* area, size_t size);
+  void grow_from_front(ZMemory* area, size_t size);
+  void grow_from_back(ZMemory* area, size_t size);
 
   ZMemoryRange alloc_low_address_inner(size_t size);
   ZMemoryRange alloc_low_address_at_most_inner(size_t size);

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

@@ -841,6 +841,8 @@ void ZPageAllocator::harvest_claimed_physical(ZPageAllocation* allocation) {
   segments.stash(allocation->claimed_mappings());
 
   // Shuffle vmem. We allocate enough memory to cover the entire allocation size, not just the harvested memory.
+  // If we fail to allocate additional virtual memory, the allocated virtual memory will match the harvested amount
+  // instead of the allocation request.
   _virtual.shuffle_vmem_to_low_addresses_contiguous(allocation->size(), allocation->claimed_mappings());
 
   // Restore segments
@@ -933,9 +935,18 @@ ZPage* ZPageAllocator::alloc_page_inner(ZPageAllocation* allocation) {
     allocation->claimed_mappings()->append(vmem);
   }
 
-  // Check if we've successfully gotten a large enough virtual address range
+  // Check if we've successfully gotten a large enough virtual address range.
   if (!is_alloc_satisfied(allocation)) {
     log_error(gc)("Out of address space");
+
+    // The harvested memory has not been mapped yet. Map it before we put it back into the cache.
+    if (allocation->harvested() > 0) {
+      ZArrayIterator<ZMemoryRange> iter(allocation->claimed_mappings());
+      for (ZMemoryRange vmem; iter.next(&vmem);) {
+        map_virtual_to_physical(vmem);
+      }
+    }
+
     free_memory_alloc_failed(allocation);
     return nullptr;
   }