src/hotspot/share/gc/g1/g1CollectedHeap.cpp

rev 52577 : imported patch webrev.0
rev 52578 : imported patch webrev.1
rev 52579 : imported patch webrev.2_reserved_page_size
rev 52580 : [mq]: webrev.3

*** 1562,1590 ****
    NOT_PRODUCT(reset_evacuation_should_fail();)
  
    guarantee(_task_queues != NULL, "task_queues allocation failure.");
  }
  
  G1RegionToSpaceMapper* G1CollectedHeap::create_aux_memory_mapper(const char* description,
                                                                   size_t size,
                                                                   size_t translation_factor) {
    size_t preferred_page_size = os::page_size_for_region_unaligned(size, 1);
    // Allocate a new reserved space, preferring to use large pages.
    ReservedSpace rs(size, preferred_page_size);
-   size_t page_size = rs.actual_page_size();
    G1RegionToSpaceMapper* result  =
      G1RegionToSpaceMapper::create_mapper(rs,
                                           size,
!                                          page_size,
                                           HeapRegion::GrainBytes,
                                           translation_factor,
                                           mtGC);
  
    os::trace_page_sizes_for_requested_size(description,
                                            size,
                                            preferred_page_size,
!                                           page_size,
                                            rs.base(),
                                            rs.size());
  
    return result;
  }
--- 1562,1605 ----
    NOT_PRODUCT(reset_evacuation_should_fail();)
  
    guarantee(_task_queues != NULL, "task_queues allocation failure.");
  }
  
+ static size_t actual_reserved_page_size(ReservedSpace rs) {
+   size_t page_size = os::vm_page_size();
+   if (UseLargePages) {
+     // There are two ways to manage large page memory.
+     // 1. OS supports committing large page memory.
+     // 2. OS doesn't support committing large page memory so ReservedSpace manages it.
+     //    And ReservedSpace calls it 'special'. If we failed to set 'special',
+     //    we reserved memory without large page.
+     if (os::can_commit_large_page_memory() || rs.special()) {
+       page_size = os::large_page_size();
+     }
+   }
+ 
+   return page_size;
+ }
+ 
  G1RegionToSpaceMapper* G1CollectedHeap::create_aux_memory_mapper(const char* description,
                                                                   size_t size,
                                                                   size_t translation_factor) {
    size_t preferred_page_size = os::page_size_for_region_unaligned(size, 1);
    // Allocate a new reserved space, preferring to use large pages.
    ReservedSpace rs(size, preferred_page_size);
    G1RegionToSpaceMapper* result  =
      G1RegionToSpaceMapper::create_mapper(rs,
                                           size,
!                                          rs.alignment(),
                                           HeapRegion::GrainBytes,
                                           translation_factor,
                                           mtGC);
  
    os::trace_page_sizes_for_requested_size(description,
                                            size,
                                            preferred_page_size,
!                                           rs.alignment(),
                                            rs.base(),
                                            rs.size());
  
    return result;
  }
*** 1657,1667 ****
    // Create the hot card cache.
    _hot_card_cache = new G1HotCardCache(this);
  
    // Carve out the G1 part of the heap.
    ReservedSpace g1_rs = heap_rs.first_part(max_byte_size);
!   size_t page_size = heap_rs.actual_page_size();
    G1RegionToSpaceMapper* heap_storage =
      G1RegionToSpaceMapper::create_mapper(g1_rs,
                                           g1_rs.size(),
                                           page_size,
                                           HeapRegion::GrainBytes,
--- 1672,1682 ----
    // Create the hot card cache.
    _hot_card_cache = new G1HotCardCache(this);
  
    // Carve out the G1 part of the heap.
    ReservedSpace g1_rs = heap_rs.first_part(max_byte_size);
!   size_t page_size = actual_reserved_page_size(heap_rs);
    G1RegionToSpaceMapper* heap_storage =
      G1RegionToSpaceMapper::create_mapper(g1_rs,
                                           g1_rs.size(),
                                           page_size,
                                           HeapRegion::GrainBytes,