src/share/vm/runtime/os.cpp

rev 7180 : 8067469: G1 ignores AlwaysPreTouch
Summary: Factor out pretouch code of the various virtual space management classes and use them everywhere including in G1.
Reviewed-by: stefank, ehelin, dholmes
rev 7181 : 8049864: TestParallelHeapSizeFlags fails with unexpected heap size
Reviewed-by: sjohanss, jmasa
rev 7183 : 8066875: VirtualSpace does not use large pages
Reviewed-by: stefank, tschatzl, anoll, thartmann

*** 1313,1338 ****
    // The very lower end of the stack
    address stack_limit = thread->stack_base() - thread->stack_size();
    return (sp > (stack_limit + reserved_area));
  }
  
! size_t os::page_size_for_region(size_t region_size, size_t min_pages) {
    assert(min_pages > 0, "sanity");
    if (UseLargePages) {
      const size_t max_page_size = region_size / min_pages;
  
      for (size_t i = 0; _page_sizes[i] != 0; ++i) {
        const size_t page_size = _page_sizes[i];
!       if (page_size <= max_page_size && is_size_aligned(region_size, page_size)) {
          return page_size;
        }
      }
    }
  
    return vm_page_size();
  }
  
  #ifndef PRODUCT
  void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count)
  {
    if (TracePageSizes) {
      tty->print("%s: ", str);
--- 1313,1348 ----
    // The very lower end of the stack
    address stack_limit = thread->stack_base() - thread->stack_size();
    return (sp > (stack_limit + reserved_area));
  }
  
! size_t os::page_size_for_region(size_t region_size, size_t min_pages, bool must_be_aligned) {
    assert(min_pages > 0, "sanity");
    if (UseLargePages) {
      const size_t max_page_size = region_size / min_pages;
  
      for (size_t i = 0; _page_sizes[i] != 0; ++i) {
        const size_t page_size = _page_sizes[i];
!       if (page_size <= max_page_size) {
!         if (!must_be_aligned || is_size_aligned(region_size, page_size)) {
            return page_size;
          }
        }
      }
+   }
  
    return vm_page_size();
  }
  
+ size_t os::page_size_for_region_aligned(size_t region_size, size_t min_pages) {
+   return page_size_for_region(region_size, min_pages, true);
+ }
+ 
+ size_t os::page_size_for_region_unaligned(size_t region_size, size_t min_pages) {
+   return page_size_for_region(region_size, min_pages, false);
+ }
+ 
  #ifndef PRODUCT
  void os::trace_page_sizes(const char* str, const size_t* page_sizes, int count)
  {
    if (TracePageSizes) {
      tty->print("%s: ", str);
*** 1577,1597 ****
      return os::vm_page_size();
    }
  
    static size_t large_page_size() {
      const size_t large_page_size_example = 4 * M;
!     return os::page_size_for_region(large_page_size_example, 1);
    }
  
!   static void test_page_size_for_region() {
      if (UseLargePages) {
        const size_t small_page = small_page_size();
        const size_t large_page = large_page_size();
  
        if (large_page > small_page) {
          size_t num_small_pages_in_large = large_page / small_page;
!         size_t page = os::page_size_for_region(large_page, num_small_pages_in_large);
  
          assert_eq(page, small_page);
        }
      }
    }
--- 1587,1607 ----
      return os::vm_page_size();
    }
  
    static size_t large_page_size() {
      const size_t large_page_size_example = 4 * M;
!     return os::page_size_for_region_aligned(large_page_size_example, 1);
    }
  
!   static void test_page_size_for_region_aligned() {
      if (UseLargePages) {
        const size_t small_page = small_page_size();
        const size_t large_page = large_page_size();
  
        if (large_page > small_page) {
          size_t num_small_pages_in_large = large_page / small_page;
!         size_t page = os::page_size_for_region_aligned(large_page, num_small_pages_in_large);
  
          assert_eq(page, small_page);
        }
      }
    }
*** 1600,1624 ****
      if (UseLargePages) {
        const size_t small_page = small_page_size();
        const size_t large_page = large_page_size();
        if (large_page > small_page) {
          const size_t unaligned_region = large_page + 17;
!         size_t page = os::page_size_for_region(unaligned_region, 1);
          assert_eq(page, small_page);
  
          const size_t num_pages = 5;
          const size_t aligned_region = large_page * num_pages;
!         page = os::page_size_for_region(aligned_region, num_pages);
          assert_eq(page, large_page);
        }
      }
    }
  
   public:
    static void run_tests() {
!     test_page_size_for_region();
      test_page_size_for_region_alignment();
    }
  };
  
  void TestOS_test() {
    TestOS::run_tests();
--- 1610,1666 ----
      if (UseLargePages) {
        const size_t small_page = small_page_size();
        const size_t large_page = large_page_size();
        if (large_page > small_page) {
          const size_t unaligned_region = large_page + 17;
!         size_t page = os::page_size_for_region_aligned(unaligned_region, 1);
          assert_eq(page, small_page);
  
          const size_t num_pages = 5;
          const size_t aligned_region = large_page * num_pages;
!         page = os::page_size_for_region_aligned(aligned_region, num_pages);
          assert_eq(page, large_page);
        }
      }
    }
  
+   static void test_page_size_for_region_unaligned() {
+     if (UseLargePages) {
+       // Given exact page size, should return that page size.
+       for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
+         size_t expected = os::_page_sizes[i];
+         size_t actual = os::page_size_for_region_unaligned(expected, 1);
+         assert_eq(expected, actual);
+       }
+ 
+       // Given slightly larger size than a page size, return the page size.
+       for (size_t i = 0; os::_page_sizes[i] != 0; i++) {
+         size_t expected = os::_page_sizes[i];
+         size_t actual = os::page_size_for_region_unaligned(expected + 17, 1);
+         assert_eq(expected, actual);
+       }
+ 
+       // Given a slightly smaller size than a page size,
+       // return the next smaller page size.
+       if (os::_page_sizes[1] > os::_page_sizes[0]) {
+         size_t expected = os::_page_sizes[0];
+         size_t actual = os::page_size_for_region_unaligned(os::_page_sizes[1] - 17, 1);
+         assert_eq(actual, expected);
+       }
+ 
+       // Return small page size for values less than a small page.
+       size_t small_page = small_page_size();
+       size_t actual = os::page_size_for_region_unaligned(small_page - 17, 1);
+       assert_eq(small_page, actual);
+     }
+   }
+ 
   public:
    static void run_tests() {
!     test_page_size_for_region_aligned();
      test_page_size_for_region_alignment();
+     test_page_size_for_region_unaligned();
    }
  };
  
  void TestOS_test() {
    TestOS::run_tests();