src/hotspot/share/gc/z/zVirtualMemory.cpp
branchdatagramsocketimpl-branch
changeset 58678 9cf78a70fa4f
parent 54834 39ba09047e19
child 58679 9c3209ff7550
equal deleted inserted replaced
58677:13588c901957 58678:9cf78a70fa4f
    25 #include "gc/z/zGlobals.hpp"
    25 #include "gc/z/zGlobals.hpp"
    26 #include "gc/z/zVirtualMemory.inline.hpp"
    26 #include "gc/z/zVirtualMemory.inline.hpp"
    27 #include "logging/log.hpp"
    27 #include "logging/log.hpp"
    28 #include "services/memTracker.hpp"
    28 #include "services/memTracker.hpp"
    29 
    29 
    30 ZVirtualMemoryManager::ZVirtualMemoryManager() :
    30 ZVirtualMemoryManager::ZVirtualMemoryManager(size_t max_capacity) :
    31     _manager(),
    31     _manager(),
    32     _initialized(false) {
    32     _initialized(false) {
    33 
    33 
    34   log_info(gc, init)("Address Space: " PTR_FORMAT " - " PTR_FORMAT " (" SIZE_FORMAT "T)",
    34   // Check max supported heap size
    35                      ZAddressSpaceStart, ZAddressSpaceEnd, ZAddressSpaceSize / K / G);
    35   if (max_capacity > ZAddressOffsetMax) {
    36 
    36     log_error(gc)("Java heap too large (max supported heap size is " SIZE_FORMAT "G)",
    37   // Reserve address space
    37                   ZAddressOffsetMax / G);
    38   if (!reserve(ZAddressSpaceStart, ZAddressSpaceSize)) {
       
    39     return;
    38     return;
    40   }
    39   }
    41 
    40 
    42   // Make the complete address view free
    41   log_info(gc, init)("Address Space: " SIZE_FORMAT "T", ZAddressOffsetMax / K / G);
    43   _manager.free(0, ZAddressOffsetMax);
       
    44 
    42 
    45   // Register address space with native memory tracker
    43   // Reserve address space
    46   nmt_reserve(ZAddressSpaceStart, ZAddressSpaceSize);
    44   if (reserve(0, ZAddressOffsetMax) < max_capacity) {
       
    45     log_error(gc)("Failed to reserve address space for Java heap");
       
    46     return;
       
    47   }
    47 
    48 
    48   // Successfully initialized
    49   // Successfully initialized
    49   _initialized = true;
    50   _initialized = true;
       
    51 }
       
    52 
       
    53 size_t ZVirtualMemoryManager::reserve(uintptr_t start, size_t size) {
       
    54   if (size < ZGranuleSize) {
       
    55     // Too small
       
    56     return 0;
       
    57   }
       
    58 
       
    59   if (!reserve_platform(start, size)) {
       
    60     const size_t half = size / 2;
       
    61     return reserve(start, half) + reserve(start + half, half);
       
    62   }
       
    63 
       
    64   // Make the address range free
       
    65   _manager.free(start, size);
       
    66 
       
    67   return size;
    50 }
    68 }
    51 
    69 
    52 void ZVirtualMemoryManager::nmt_reserve(uintptr_t start, size_t size) {
    70 void ZVirtualMemoryManager::nmt_reserve(uintptr_t start, size_t size) {
    53   MemTracker::record_virtual_memory_reserve((void*)start, size, CALLER_PC);
    71   MemTracker::record_virtual_memory_reserve((void*)start, size, CALLER_PC);
    54   MemTracker::record_virtual_memory_type((void*)start, mtJavaHeap);
    72   MemTracker::record_virtual_memory_type((void*)start, mtJavaHeap);