# HG changeset patch
# User ehelin
# Date 1421335217 -3600
#      Thu Jan 15 16:20:17 2015 +0100
# Node ID 5b50a6f461e1c201dadc42c4acb3295a66a1b1cd
# Parent  a68db7fb06c3a834c72f1e7ef3d83a4f641f9155
8066875: VirtualSpace does not use large pages (02)

diff --git a/src/share/vm/runtime/os.cpp b/src/share/vm/runtime/os.cpp
--- a/src/share/vm/runtime/os.cpp
+++ b/src/share/vm/runtime/os.cpp
@@ -1402,20 +1402,17 @@ bool os::stack_shadow_pages_available(Th
 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) {
-          return page_size;
-        }
-        if (is_size_aligned(region_size, page_size)) {
+        if (!must_be_aligned || is_size_aligned(region_size, page_size)) {
           return page_size;
         }
       }
     }
   }
 
   return vm_page_size();
 }
@@ -1707,39 +1704,39 @@ class TestOS : AllStatic {
         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
+      // 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
+      // 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
+      // 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
+      // 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() {
diff --git a/src/share/vm/runtime/virtualspace.cpp b/src/share/vm/runtime/virtualspace.cpp
--- a/src/share/vm/runtime/virtualspace.cpp
+++ b/src/share/vm/runtime/virtualspace.cpp
@@ -33,17 +33,18 @@ PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 // ReservedSpace
 
 // Dummy constructor
 ReservedSpace::ReservedSpace() : _base(NULL), _size(0), _noaccess_prefix(0),
     _alignment(0), _special(false), _executable(false) {
 }
 
 ReservedSpace::ReservedSpace(size_t size) {
-  size_t page_size = os::page_size_for_region_aligned(size, 1);
+  // Want to use large pages where possible and pad with small pages.
+  size_t page_size = os::page_size_for_region_unaligned(size, 1);
   bool large_pages = page_size != (size_t)os::vm_page_size();
   // Don't force the alignment to be large page aligned,
   // since that will waste memory.
   size_t alignment = os::vm_allocation_granularity();
   initialize(size, alignment, large_pages, NULL, false);
 }
 
 ReservedSpace::ReservedSpace(size_t size, size_t alignment,