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

@@ -27,11 +27,10 @@
 #include "gc/z/zAllocationFlags.hpp"
 #include "gc/z/zList.hpp"
 #include "gc/z/zLock.hpp"
 #include "gc/z/zPageCache.hpp"
 #include "gc/z/zPhysicalMemory.hpp"
-#include "gc/z/zPreMappedMemory.hpp"
 #include "gc/z/zSafeDelete.hpp"
 #include "gc/z/zVirtualMemory.hpp"
 #include "memory/allocation.hpp"
 
 class ZPageAllocRequest;

@@ -42,52 +41,60 @@
 private:
   ZLock                      _lock;
   ZVirtualMemoryManager      _virtual;
   ZPhysicalMemoryManager     _physical;
   ZPageCache                 _cache;
+  const size_t               _min_capacity;
+  const size_t               _max_capacity;
   const size_t               _max_reserve;
-  ZPreMappedMemory           _pre_mapped;
+  size_t                     _current_max_capacity;
+  size_t                     _capacity;
   size_t                     _used_high;
   size_t                     _used_low;
   size_t                     _used;
   size_t                     _allocated;
   ssize_t                    _reclaimed;
   ZList<ZPageAllocRequest>   _queue;
   mutable ZSafeDelete<ZPage> _safe_delete;
+  bool                       _uncommit;
+  bool                       _initialized;
 
   static ZPage* const      gc_marker;
 
+  void prime_cache(size_t size);
+
   void increase_used(size_t size, bool relocation);
   void decrease_used(size_t size, bool reclaimed);
 
-  size_t max_available(bool no_reserve) const;
-  size_t try_ensure_unused(size_t size, bool no_reserve);
-  size_t try_ensure_unused_for_pre_mapped(size_t size);
-
   ZPage* create_page(uint8_t type, size_t size);
   void destroy_page(ZPage* page);
 
-  void flush_pre_mapped();
-  void flush_cache(ZPageCacheFlushClosure* cl);
-  void evict_cache(size_t requested);
+  size_t max_available(bool no_reserve) const;
+  bool ensure_available(size_t size, bool no_reserve);
+  void ensure_uncached_available(size_t size);
 
   void check_out_of_memory_during_initialization();
 
-  ZPage* alloc_page_common_inner(uint8_t type, size_t size, ZAllocationFlags flags);
+  ZPage* alloc_page_common_inner(uint8_t type, size_t size, bool no_reserve);
   ZPage* alloc_page_common(uint8_t type, size_t size, ZAllocationFlags flags);
   ZPage* alloc_page_blocking(uint8_t type, size_t size, ZAllocationFlags flags);
   ZPage* alloc_page_nonblocking(uint8_t type, size_t size, ZAllocationFlags flags);
 
-  void satisfy_alloc_queue();
+  size_t flush_cache(ZPageCacheFlushClosure* cl);
+  void flush_cache_for_allocation(size_t requested);
 
-  void detach_memory(const ZVirtualMemory& vmem, ZPhysicalMemory& pmem);
+  void satisfy_alloc_queue();
 
 public:
-  ZPageAllocator(size_t min_capacity, size_t max_capacity, size_t max_reserve);
+  ZPageAllocator(size_t min_capacity,
+                 size_t initial_capacity,
+                 size_t max_capacity,
+                 size_t max_reserve);
 
   bool is_initialized() const;
 
+  size_t min_capacity() const;
   size_t max_capacity() const;
   size_t current_max_capacity() const;
   size_t capacity() const;
   size_t max_reserve() const;
   size_t used_high() const;

@@ -100,10 +107,12 @@
   void reset_statistics();
 
   ZPage* alloc_page(uint8_t type, size_t size, ZAllocationFlags flags);
   void free_page(ZPage* page, bool reclaimed);
 
+  uint64_t uncommit(uint64_t delay);
+
   void enable_deferred_delete() const;
   void disable_deferred_delete() const;
 
   void map_page(ZPage* page);
   void unmap_all_pages();