*** old/src/share/vm/runtime/virtualspace.cpp	Thu Aug 22 13:04:00 2013
--- new/src/share/vm/runtime/virtualspace.cpp	Thu Aug 22 13:03:59 2013

*** 40,51 ****
--- 40,62 ----
  # include "os_bsd.inline.hpp"
  #endif
  
  
  // ReservedSpace
+ 
+ // Dummy constructor
+ ReservedSpace::ReservedSpace() : _base(NULL), _size(0), _noaccess_prefix(0),
+     _alignment(0), _special(false), _executable(false) {
+ }
+ 
  ReservedSpace::ReservedSpace(size_t size) {
!   initialize(size, 0, false, NULL, 0, false);
!   size_t page_size = os::page_size_for_region(size, 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, 0, false);
  }
  
  ReservedSpace::ReservedSpace(size_t size, size_t alignment,
                               bool large,
                               char* requested_address,

*** 127,146 ****
--- 138,159 ----
      assert(requested_address != NULL, "huge noaccess prefix?");
    }
  
    if (special) {
  
!     base = os::reserve_memory_special(size, alignment, requested_address, executable);
  
      if (base != NULL) {
        if (failed_to_reserve_as_requested(base, requested_address, size, true)) {
          // OS ignored requested address. Try different address.
          return;
        }
!       // Check alignment constraints.
        assert((uintptr_t) base % alignment == 0,
               "Large pages returned a non-aligned address");
+              err_msg("Large pages returned a non-aligned address, base: "
+                  PTR_FORMAT " alignment: " PTR_FORMAT,
+                  base, (void*)(uintptr_t)alignment));
        _special = true;
      } else {
        // failed; try to reserve regular memory below
        if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) ||
                              !FLAG_IS_DEFAULT(LargePageSizeInBytes))) {

*** 713,718 ****
--- 726,915 ----
    tty->print_cr(" - reserved:  " SIZE_FORMAT, reserved_size());
    tty->print_cr(" - [low, high]:     [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",  low(), high());
    tty->print_cr(" - [low_b, high_b]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",  low_boundary(), high_boundary());
  }
  
+ 
+ /////////////// Unit tests ///////////////
+ 
+ #ifndef PRODUCT
+ 
+ #define test_log(...) \
+   do {\
+     if (VerboseInternalVMTests) { \
+       tty->print_cr(__VA_ARGS__); \
+       tty->flush(); \
+     }\
+   } while (false)
+ 
+ class TestReservedSpace : AllStatic {
+  public:
+   static void small_page_write(void* addr, size_t size) {
+     size_t page_size = os::vm_page_size();
+ 
+     char* end = (char*)addr + size;
+     for (char* p = (char*)addr; p < end; p += page_size) {
+       *p = 1;
+     }
+   }
+ 
+   static void release_memory_for_test(ReservedSpace rs) {
+     if (rs.special()) {
+       guarantee(os::release_memory_special(rs.base(), rs.size()), "Shouldn't fail");
+     } else {
+       guarantee(os::release_memory(rs.base(), rs.size()), "Shouldn't fail");
+     }
+   }
+ 
+   static void test_reserved_space1(size_t size, size_t alignment) {
+     test_log("test_reserved_space1(%p)", (void*) (uintptr_t) size);
+ 
+     assert(is_size_aligned(size, alignment), "Incorrect input parameters");
+ 
+     ReservedSpace rs(size,          // size
+                      alignment,     // alignment
+                      UseLargePages, // large
+                      NULL,          // requested_address
+                      0);            // noacces_prefix
+ 
+     test_log(" rs.special() == %d", rs.special());
+ 
+     assert(rs.base() != NULL, "Must be");
+     assert(rs.size() == size, "Must be");
+ 
+     assert(is_ptr_aligned(rs.base(), alignment), "aligned sizes should always give aligned addresses");
+     assert(is_size_aligned(rs.size(), alignment), "aligned sizes should always give aligned addresses");
+ 
+     if (rs.special()) {
+       small_page_write(rs.base(), size);
+     }
+ 
+     release_memory_for_test(rs);
+   }
+ 
+   static void test_reserved_space2(size_t size) {
+     test_log("test_reserved_space2(%p)", (void*)(uintptr_t)size);
+ 
+     assert(is_size_aligned(size, os::vm_allocation_granularity()), "Must be at least AG aligned");
+ 
+     ReservedSpace rs(size);
+ 
+     test_log(" rs.special() == %d", rs.special());
+ 
+     assert(rs.base() != NULL, "Must be");
+     assert(rs.size() == size, "Must be");
+ 
+     if (rs.special()) {
+       small_page_write(rs.base(), size);
+     }
+ 
+     release_memory_for_test(rs);
+   }
+ 
+   static void test_reserved_space3(size_t size, size_t alignment, bool maybe_large) {
+     test_log("test_reserved_space3(%p, %p, %d)",
+         (void*)(uintptr_t)size, (void*)(uintptr_t)alignment, maybe_large);
+ 
+     assert(is_size_aligned(size, os::vm_allocation_granularity()), "Must be at least AG aligned");
+     assert(is_size_aligned(size, alignment), "Must be at least aligned against alignment");
+ 
+     bool large = maybe_large && UseLargePages && size >= os::large_page_size();
+ 
+     ReservedSpace rs(size, alignment, large, false);
+ 
+     test_log(" rs.special() == %d", rs.special());
+ 
+     assert(rs.base() != NULL, "Must be");
+     assert(rs.size() == size, "Must be");
+ 
+     if (rs.special()) {
+       small_page_write(rs.base(), size);
+     }
+ 
+     release_memory_for_test(rs);
+   }
+ 
+ 
+   static void test_reserved_space1() {
+     size_t size = 2 * 1024 * 1024;
+     size_t ag   = os::vm_allocation_granularity();
+ 
+     test_reserved_space1(size,      ag);
+     test_reserved_space1(size * 2,  ag);
+     test_reserved_space1(size * 10, ag);
+   }
+ 
+   static void test_reserved_space2() {
+     size_t size = 2 * 1024 * 1024;
+     size_t ag = os::vm_allocation_granularity();
+ 
+     test_reserved_space2(size * 1);
+     test_reserved_space2(size * 2);
+     test_reserved_space2(size * 10);
+     test_reserved_space2(ag);
+     test_reserved_space2(size - ag);
+     test_reserved_space2(size);
+     test_reserved_space2(size + ag);
+     test_reserved_space2(size * 2);
+     test_reserved_space2(size * 2 - ag);
+     test_reserved_space2(size * 2 + ag);
+     test_reserved_space2(size * 3);
+     test_reserved_space2(size * 3 - ag);
+     test_reserved_space2(size * 3 + ag);
+     test_reserved_space2(size * 10);
+     test_reserved_space2(size * 10 + size / 2);
+   }
+ 
+   static void test_reserved_space3() {
+     size_t ag = os::vm_allocation_granularity();
+ 
+     test_reserved_space3(ag,      ag    , false);
+     test_reserved_space3(ag * 2,  ag    , false);
+     test_reserved_space3(ag * 3,  ag    , false);
+     test_reserved_space3(ag * 2,  ag * 2, false);
+     test_reserved_space3(ag * 4,  ag * 2, false);
+     test_reserved_space3(ag * 8,  ag * 2, false);
+     test_reserved_space3(ag * 4,  ag * 4, false);
+     test_reserved_space3(ag * 8,  ag * 4, false);
+     test_reserved_space3(ag * 16, ag * 4, false);
+ 
+     if (UseLargePages) {
+       size_t lp = os::large_page_size();
+ 
+       // Without large pages
+       test_reserved_space3(lp,     ag * 4, false);
+       test_reserved_space3(lp * 2, ag * 4, false);
+       test_reserved_space3(lp * 4, ag * 4, false);
+       test_reserved_space3(lp,     lp    , false);
+       test_reserved_space3(lp * 2, lp    , false);
+       test_reserved_space3(lp * 3, lp    , false);
+       test_reserved_space3(lp * 2, lp * 2, false);
+       test_reserved_space3(lp * 4, lp * 2, false);
+       test_reserved_space3(lp * 8, lp * 2, false);
+ 
+       // With large pages
+       test_reserved_space3(lp, ag * 4    , true);
+       test_reserved_space3(lp * 2, ag * 4, true);
+       test_reserved_space3(lp * 4, ag * 4, true);
+       test_reserved_space3(lp, lp        , true);
+       test_reserved_space3(lp * 2, lp    , true);
+       test_reserved_space3(lp * 3, lp    , true);
+       test_reserved_space3(lp * 2, lp * 2, true);
+       test_reserved_space3(lp * 4, lp * 2, true);
+       test_reserved_space3(lp * 8, lp * 2, true);
+     }
+   }
+ 
+   static void test_reserved_space() {
+     test_reserved_space1();
+     test_reserved_space2();
+     test_reserved_space3();
+   }
+ };
+ 
+ void TestReservedSpace_test() {
+   TestReservedSpace::test_reserved_space();
+ }
+ 
+ #endif // PRODUCT
+ 
  #endif