1 /*
   2  * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "logging/log.hpp"
  27 #include "memory/resourceArea.hpp"
  28 #include "memory/virtualspace.hpp"
  29 #include "oops/compressedOops.hpp"
  30 #include "oops/markWord.hpp"
  31 #include "oops/oop.inline.hpp"
  32 #include "runtime/os.inline.hpp"
  33 #include "services/memTracker.hpp"
  34 #include "utilities/align.hpp"
  35 #include "utilities/powerOfTwo.hpp"
  36 
  37 // ReservedSpace
  38 
  39 // Dummy constructor
  40 ReservedSpace::ReservedSpace() : _base(NULL), _size(0), _noaccess_prefix(0),
  41     _alignment(0), _special(false), _fd_for_heap(-1), _executable(false) {
  42 }
  43 
  44 ReservedSpace::ReservedSpace(size_t size, size_t preferred_page_size) : _fd_for_heap(-1) {
  45   bool has_preferred_page_size = preferred_page_size != 0;
  46   // Want to use large pages where possible and pad with small pages.
  47   size_t page_size = has_preferred_page_size ? preferred_page_size : os::page_size_for_region_unaligned(size, 1);
  48   bool large_pages = page_size != (size_t)os::vm_page_size();
  49   size_t alignment;
  50   if (large_pages && has_preferred_page_size) {
  51     alignment = MAX2(page_size, (size_t)os::vm_allocation_granularity());
  52     // ReservedSpace initialization requires size to be aligned to the given
  53     // alignment. Align the size up.
  54     size = align_up(size, alignment);
  55   } else {
  56     // Don't force the alignment to be large page aligned,
  57     // since that will waste memory.
  58     alignment = os::vm_allocation_granularity();
  59   }
  60   initialize(size, alignment, large_pages, NULL, false);
  61 }
  62 
  63 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
  64                              bool large,
  65                              char* requested_address) : _fd_for_heap(-1) {
  66   initialize(size, alignment, large, requested_address, false);
  67 }
  68 
  69 ReservedSpace::ReservedSpace(char* base, size_t size, size_t alignment,
  70                              bool special, bool executable) : _fd_for_heap(-1) {
  71   assert((size % os::vm_allocation_granularity()) == 0,
  72          "size not allocation aligned");
  73   _base = base;
  74   _size = size;
  75   _alignment = alignment;
  76   _noaccess_prefix = 0;
  77   _special = special;
  78   _executable = executable;
  79 }
  80 
  81 // Helper method
  82 static void unmap_or_release_memory(char* base, size_t size, bool is_file_mapped) {
  83   if (is_file_mapped) {
  84     if (!os::unmap_memory(base, size)) {
  85       fatal("os::unmap_memory failed");
  86     }
  87   } else if (!os::release_memory(base, size)) {
  88     fatal("os::release_memory failed");
  89   }
  90 }
  91 
  92 // Helper method.
  93 static bool failed_to_reserve_as_requested(char* base, char* requested_address,
  94                                            const size_t size, bool special, bool is_file_mapped = false)
  95 {
  96   if (base == requested_address || requested_address == NULL)
  97     return false; // did not fail
  98 
  99   if (base != NULL) {
 100     // Different reserve address may be acceptable in other cases
 101     // but for compressed oops heap should be at requested address.
 102     assert(UseCompressedOops, "currently requested address used only for compressed oops");
 103     log_debug(gc, heap, coops)("Reserved memory not at requested address: " PTR_FORMAT " vs " PTR_FORMAT, p2i(base), p2i(requested_address));
 104     // OS ignored requested address. Try different address.
 105     if (special) {
 106       if (!os::release_memory_special(base, size)) {
 107         fatal("os::release_memory_special failed");
 108       }
 109     } else {
 110       unmap_or_release_memory(base, size, is_file_mapped);
 111     }
 112   }
 113   return true;
 114 }
 115 
 116 // Helper method.
 117 static bool should_use_reserve_memory_special(bool large, 
 118                                               int fd_for_heap, 
 119                                               const char* fallback_log_message)
 120 {
 121   // If OS doesn't support demand paging for large page memory, we need
 122   // to use reserve_memory_special() to reserve and pin the entire region.
 123   // If there is a backing file directory for this space then whether
 124   // large pages are allocated is up to the filesystem of the backing file.
 125   // So we ignore the UseLargePages flag in this case.
 126   bool special = large && !os::can_commit_large_page_memory();
 127   if (special && fd_for_heap != -1) {
 128     special = false;
 129     if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) ||
 130                           !FLAG_IS_DEFAULT(LargePageSizeInBytes))) {
 131       log_debug(gc, heap)("%s", fallback_log_message);
 132     }
 133   }
 134   return special;
 135 }
 136 
 137 void ReservedSpace::initialize(size_t size, size_t alignment, bool large,
 138                                char* requested_address,
 139                                bool executable) {
 140   const size_t granularity = os::vm_allocation_granularity();
 141   assert((size & (granularity - 1)) == 0,
 142          "size not aligned to os::vm_allocation_granularity()");
 143   assert((alignment & (granularity - 1)) == 0,
 144          "alignment not aligned to os::vm_allocation_granularity()");
 145   assert(alignment == 0 || is_power_of_2((intptr_t)alignment),
 146          "not a power of 2");
 147 
 148   alignment = MAX2(alignment, (size_t)os::vm_page_size());
 149 
 150   _base = NULL;
 151   _size = 0;
 152   _special = false;
 153   _executable = executable;
 154   _alignment = 0;
 155   _noaccess_prefix = 0;
 156   if (size == 0) {
 157     return;
 158   }
 159 
 160   bool special = should_use_reserve_memory_special(large, _fd_for_heap, 
 161                                                    "Ignoring UseLargePages since large page "
 162                                                    "support is up to the file system of the "
 163                                                    "backing file for Java heap");









 164 
 165   char* base = NULL;
 166 
 167   if (special) {
 168 
 169     base = os::reserve_memory_special(size, alignment, requested_address, executable);
 170 
 171     if (base != NULL) {
 172       if (failed_to_reserve_as_requested(base, requested_address, size, true)) {
 173         // OS ignored requested address. Try different address.
 174         return;
 175       }
 176       // Check alignment constraints.
 177       assert((uintptr_t) base % alignment == 0,
 178              "Large pages returned a non-aligned address, base: "
 179              PTR_FORMAT " alignment: " SIZE_FORMAT_HEX,
 180              p2i(base), alignment);
 181       _special = true;
 182     } else {
 183       // failed; try to reserve regular memory below
 184       if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) ||
 185                             !FLAG_IS_DEFAULT(LargePageSizeInBytes))) {
 186         log_debug(gc, heap, coops)("Reserve regular memory without large pages");
 187       }
 188     }
 189   }
 190 
 191   if (base == NULL) {
 192     // Optimistically assume that the OSes returns an aligned base pointer.
 193     // When reserving a large address range, most OSes seem to align to at
 194     // least 64K.
 195 
 196     // If the memory was requested at a particular address, use
 197     // os::attempt_reserve_memory_at() to avoid over mapping something
 198     // important.  If available space is not detected, return NULL.
 199 
 200     if (requested_address != 0) {
 201       base = os::attempt_reserve_memory_at(size, requested_address, _fd_for_heap);
 202       if (failed_to_reserve_as_requested(base, requested_address, size, false, _fd_for_heap != -1)) {
 203         // OS ignored requested address. Try different address.
 204         base = NULL;
 205       }
 206     } else {
 207       base = os::reserve_memory(size, NULL, alignment, _fd_for_heap);
 208     }
 209 
 210     if (base == NULL) return;
 211 
 212     // Check alignment constraints
 213     if ((((size_t)base) & (alignment - 1)) != 0) {
 214       // Base not aligned, retry
 215       unmap_or_release_memory(base, size, _fd_for_heap != -1 /*is_file_mapped*/);
 216 
 217       // Make sure that size is aligned
 218       size = align_up(size, alignment);
 219       base = os::reserve_memory_aligned(size, alignment, _fd_for_heap);
 220 
 221       if (requested_address != 0 &&
 222           failed_to_reserve_as_requested(base, requested_address, size, false, _fd_for_heap != -1)) {
 223         // As a result of the alignment constraints, the allocated base differs
 224         // from the requested address. Return back to the caller who can
 225         // take remedial action (like try again without a requested address).
 226         assert(_base == NULL, "should be");
 227         return;
 228       }
 229     }
 230   }
 231   // Done
 232   _base = base;
 233   _size = size;
 234   _alignment = alignment;
 235   // If heap is reserved with a backing file, the entire space has been committed. So set the _special flag to true
 236   if (_fd_for_heap != -1) {
 237     _special = true;
 238   }
 239 }
 240 
 241 ReservedSpace ReservedSpace::first_part(size_t partition_size, size_t alignment, bool split) {
 242   assert(partition_size <= size(), "partition failed");
 243   if (split && partition_size > 0 && partition_size < size()) {
 244     os::split_reserved_memory(base(), size(), partition_size);
 245   }
 246   ReservedSpace result(base(), partition_size, alignment, special(),
 247                        executable());
 248   return result;
 249 }
 250 
 251 
 252 ReservedSpace
 253 ReservedSpace::last_part(size_t partition_size, size_t alignment) {
 254   assert(partition_size <= size(), "partition failed");
 255   ReservedSpace result(base() + partition_size, size() - partition_size,
 256                        alignment, special(), executable());
 257   return result;
 258 }
 259 
 260 
 261 size_t ReservedSpace::page_align_size_up(size_t size) {
 262   return align_up(size, os::vm_page_size());
 263 }
 264 
 265 
 266 size_t ReservedSpace::page_align_size_down(size_t size) {
 267   return align_down(size, os::vm_page_size());
 268 }
 269 
 270 
 271 size_t ReservedSpace::allocation_align_size_up(size_t size) {
 272   return align_up(size, os::vm_allocation_granularity());
 273 }
 274 
 275 
 276 void ReservedSpace::release() {
 277   if (is_reserved()) {
 278     char *real_base = _base - _noaccess_prefix;
 279     const size_t real_size = _size + _noaccess_prefix;
 280     if (special()) {
 281       if (_fd_for_heap != -1) {
 282         os::unmap_memory(real_base, real_size);
 283       } else {
 284         os::release_memory_special(real_base, real_size);
 285       }
 286     } else{
 287       os::release_memory(real_base, real_size);
 288     }
 289     _base = NULL;
 290     _size = 0;
 291     _noaccess_prefix = 0;
 292     _alignment = 0;
 293     _special = false;
 294     _executable = false;
 295   }
 296 }
 297 
 298 static size_t noaccess_prefix_size(size_t alignment) {
 299   return lcm(os::vm_page_size(), alignment);
 300 }
 301 
 302 void ReservedHeapSpace::establish_noaccess_prefix() {
 303   assert(_alignment >= (size_t)os::vm_page_size(), "must be at least page size big");
 304   _noaccess_prefix = noaccess_prefix_size(_alignment);
 305 
 306   if (base() && base() + _size > (char *)OopEncodingHeapMax) {
 307     if (true
 308         WIN64_ONLY(&& !UseLargePages)
 309         AIX_ONLY(&& os::vm_page_size() != 64*K)) {
 310       // Protect memory at the base of the allocated region.
 311       // If special, the page was committed (only matters on windows)
 312       if (!os::protect_memory(_base, _noaccess_prefix, os::MEM_PROT_NONE, _special)) {
 313         fatal("cannot protect protection page");
 314       }
 315       log_debug(gc, heap, coops)("Protected page at the reserved heap base: "
 316                                  PTR_FORMAT " / " INTX_FORMAT " bytes",
 317                                  p2i(_base),
 318                                  _noaccess_prefix);
 319       assert(CompressedOops::use_implicit_null_checks() == true, "not initialized?");
 320     } else {
 321       CompressedOops::set_use_implicit_null_checks(false);
 322     }
 323   }
 324 
 325   _base += _noaccess_prefix;
 326   _size -= _noaccess_prefix;
 327   assert(((uintptr_t)_base % _alignment == 0), "must be exactly of required alignment");
 328 }
 329 
 330 // Tries to allocate memory of size 'size' at address requested_address with alignment 'alignment'.
 331 // Does not check whether the reserved memory actually is at requested_address, as the memory returned
 332 // might still fulfill the wishes of the caller.
 333 // Assures the memory is aligned to 'alignment'.
 334 // NOTE: If ReservedHeapSpace already points to some reserved memory this is freed, first.
 335 void ReservedHeapSpace::try_reserve_heap(size_t size,
 336                                          size_t alignment,
 337                                          bool large,
 338                                          char* requested_address) {
 339   if (_base != NULL) {
 340     // We tried before, but we didn't like the address delivered.
 341     release();
 342   }
 343 
 344   bool special = should_use_reserve_memory_special(large, _fd_for_heap, 
 345                                                    "Cannot allocate large pages for Java Heap "
 346                                                    "when AllocateHeapAt option is set.");










 347   char* base = NULL;
 348 
 349   log_trace(gc, heap, coops)("Trying to allocate at address " PTR_FORMAT
 350                              " heap of size " SIZE_FORMAT_HEX,
 351                              p2i(requested_address),
 352                              size);
 353 
 354   if (special) {
 355     base = os::reserve_memory_special(size, alignment, requested_address, false);
 356 
 357     if (base != NULL) {
 358       // Check alignment constraints.
 359       assert((uintptr_t) base % alignment == 0,
 360              "Large pages returned a non-aligned address, base: "
 361              PTR_FORMAT " alignment: " SIZE_FORMAT_HEX,
 362              p2i(base), alignment);
 363       _special = true;
 364     }
 365   }
 366 
 367   if (base == NULL) {
 368     // Failed; try to reserve regular memory below
 369     if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) ||
 370                           !FLAG_IS_DEFAULT(LargePageSizeInBytes))) {
 371       log_debug(gc, heap, coops)("Reserve regular memory without large pages");
 372     }
 373 
 374     // Optimistically assume that the OSes returns an aligned base pointer.
 375     // When reserving a large address range, most OSes seem to align to at
 376     // least 64K.
 377 
 378     // If the memory was requested at a particular address, use
 379     // os::attempt_reserve_memory_at() to avoid over mapping something
 380     // important.  If available space is not detected, return NULL.
 381 
 382     if (requested_address != 0) {
 383       base = os::attempt_reserve_memory_at(size, requested_address, _fd_for_heap);
 384     } else {
 385       base = os::reserve_memory(size, NULL, alignment, _fd_for_heap);
 386     }
 387   }
 388   if (base == NULL) { return; }
 389 
 390   // Done
 391   _base = base;
 392   _size = size;
 393   _alignment = alignment;
 394 
 395   // If heap is reserved with a backing file, the entire space has been committed. So set the _special flag to true
 396   if (_fd_for_heap != -1) {
 397     _special = true;
 398   }
 399 
 400   // Check alignment constraints
 401   if ((((size_t)base) & (alignment - 1)) != 0) {
 402     // Base not aligned, retry.
 403     release();
 404   }
 405 }
 406 
 407 void ReservedHeapSpace::try_reserve_range(char *highest_start,
 408                                           char *lowest_start,
 409                                           size_t attach_point_alignment,
 410                                           char *aligned_heap_base_min_address,
 411                                           char *upper_bound,
 412                                           size_t size,
 413                                           size_t alignment,
 414                                           bool large) {
 415   const size_t attach_range = highest_start - lowest_start;
 416   // Cap num_attempts at possible number.
 417   // At least one is possible even for 0 sized attach range.
 418   const uint64_t num_attempts_possible = (attach_range / attach_point_alignment) + 1;
 419   const uint64_t num_attempts_to_try   = MIN2((uint64_t)HeapSearchSteps, num_attempts_possible);
 420 
 421   const size_t stepsize = (attach_range == 0) ? // Only one try.
 422     (size_t) highest_start : align_up(attach_range / num_attempts_to_try, attach_point_alignment);
 423 
 424   // Try attach points from top to bottom.
 425   char* attach_point = highest_start;
 426   while (attach_point >= lowest_start  &&
 427          attach_point <= highest_start &&  // Avoid wrap around.
 428          ((_base == NULL) ||
 429           (_base < aligned_heap_base_min_address || _base + size > upper_bound))) {
 430     try_reserve_heap(size, alignment, large, attach_point);
 431     attach_point -= stepsize;
 432   }
 433 }
 434 
 435 #define SIZE_64K  ((uint64_t) UCONST64(      0x10000))
 436 #define SIZE_256M ((uint64_t) UCONST64(   0x10000000))
 437 #define SIZE_32G  ((uint64_t) UCONST64(  0x800000000))
 438 
 439 // Helper for heap allocation. Returns an array with addresses
 440 // (OS-specific) which are suited for disjoint base mode. Array is
 441 // NULL terminated.
 442 static char** get_attach_addresses_for_disjoint_mode() {
 443   static uint64_t addresses[] = {
 444      2 * SIZE_32G,
 445      3 * SIZE_32G,
 446      4 * SIZE_32G,
 447      8 * SIZE_32G,
 448     10 * SIZE_32G,
 449      1 * SIZE_64K * SIZE_32G,
 450      2 * SIZE_64K * SIZE_32G,
 451      3 * SIZE_64K * SIZE_32G,
 452      4 * SIZE_64K * SIZE_32G,
 453     16 * SIZE_64K * SIZE_32G,
 454     32 * SIZE_64K * SIZE_32G,
 455     34 * SIZE_64K * SIZE_32G,
 456     0
 457   };
 458 
 459   // Sort out addresses smaller than HeapBaseMinAddress. This assumes
 460   // the array is sorted.
 461   uint i = 0;
 462   while (addresses[i] != 0 &&
 463          (addresses[i] < OopEncodingHeapMax || addresses[i] < HeapBaseMinAddress)) {
 464     i++;
 465   }
 466   uint start = i;
 467 
 468   // Avoid more steps than requested.
 469   i = 0;
 470   while (addresses[start+i] != 0) {
 471     if (i == HeapSearchSteps) {
 472       addresses[start+i] = 0;
 473       break;
 474     }
 475     i++;
 476   }
 477 
 478   return (char**) &addresses[start];
 479 }
 480 
 481 void ReservedHeapSpace::initialize_compressed_heap(const size_t size, size_t alignment, bool large) {
 482   guarantee(size + noaccess_prefix_size(alignment) <= OopEncodingHeapMax,
 483             "can not allocate compressed oop heap for this size");
 484   guarantee(alignment == MAX2(alignment, (size_t)os::vm_page_size()), "alignment too small");
 485 
 486   const size_t granularity = os::vm_allocation_granularity();
 487   assert((size & (granularity - 1)) == 0,
 488          "size not aligned to os::vm_allocation_granularity()");
 489   assert((alignment & (granularity - 1)) == 0,
 490          "alignment not aligned to os::vm_allocation_granularity()");
 491   assert(alignment == 0 || is_power_of_2((intptr_t)alignment),
 492          "not a power of 2");
 493 
 494   // The necessary attach point alignment for generated wish addresses.
 495   // This is needed to increase the chance of attaching for mmap and shmat.
 496   const size_t os_attach_point_alignment =
 497     AIX_ONLY(SIZE_256M)  // Known shm boundary alignment.
 498     NOT_AIX(os::vm_allocation_granularity());
 499   const size_t attach_point_alignment = lcm(alignment, os_attach_point_alignment);
 500 
 501   char *aligned_heap_base_min_address = (char *)align_up((void *)HeapBaseMinAddress, alignment);
 502   size_t noaccess_prefix = ((aligned_heap_base_min_address + size) > (char*)OopEncodingHeapMax) ?
 503     noaccess_prefix_size(alignment) : 0;
 504 
 505   // Attempt to alloc at user-given address.
 506   if (!FLAG_IS_DEFAULT(HeapBaseMinAddress)) {
 507     try_reserve_heap(size + noaccess_prefix, alignment, large, aligned_heap_base_min_address);
 508     if (_base != aligned_heap_base_min_address) { // Enforce this exact address.
 509       release();
 510     }
 511   }
 512 
 513   // Keep heap at HeapBaseMinAddress.
 514   if (_base == NULL) {
 515 
 516     // Try to allocate the heap at addresses that allow efficient oop compression.
 517     // Different schemes are tried, in order of decreasing optimization potential.
 518     //
 519     // For this, try_reserve_heap() is called with the desired heap base addresses.
 520     // A call into the os layer to allocate at a given address can return memory
 521     // at a different address than requested.  Still, this might be memory at a useful
 522     // address. try_reserve_heap() always returns this allocated memory, as only here
 523     // the criteria for a good heap are checked.
 524 
 525     // Attempt to allocate so that we can run without base and scale (32-Bit unscaled compressed oops).
 526     // Give it several tries from top of range to bottom.
 527     if (aligned_heap_base_min_address + size <= (char *)UnscaledOopHeapMax) {
 528 
 529       // Calc address range within we try to attach (range of possible start addresses).
 530       char* const highest_start = align_down((char *)UnscaledOopHeapMax - size, attach_point_alignment);
 531       char* const lowest_start  = align_up(aligned_heap_base_min_address, attach_point_alignment);
 532       try_reserve_range(highest_start, lowest_start, attach_point_alignment,
 533                         aligned_heap_base_min_address, (char *)UnscaledOopHeapMax, size, alignment, large);
 534     }
 535 
 536     // zerobased: Attempt to allocate in the lower 32G.
 537     // But leave room for the compressed class pointers, which is allocated above
 538     // the heap.
 539     char *zerobased_max = (char *)OopEncodingHeapMax;
 540     const size_t class_space = align_up(CompressedClassSpaceSize, alignment);
 541     // For small heaps, save some space for compressed class pointer
 542     // space so it can be decoded with no base.
 543     if (UseCompressedClassPointers && !UseSharedSpaces &&
 544         OopEncodingHeapMax <= KlassEncodingMetaspaceMax &&
 545         (uint64_t)(aligned_heap_base_min_address + size + class_space) <= KlassEncodingMetaspaceMax) {
 546       zerobased_max = (char *)OopEncodingHeapMax - class_space;
 547     }
 548 
 549     // Give it several tries from top of range to bottom.
 550     if (aligned_heap_base_min_address + size <= zerobased_max &&    // Zerobased theoretical possible.
 551         ((_base == NULL) ||                        // No previous try succeeded.
 552          (_base + size > zerobased_max))) {        // Unscaled delivered an arbitrary address.
 553 
 554       // Calc address range within we try to attach (range of possible start addresses).
 555       char *const highest_start = align_down(zerobased_max - size, attach_point_alignment);
 556       // Need to be careful about size being guaranteed to be less
 557       // than UnscaledOopHeapMax due to type constraints.
 558       char *lowest_start = aligned_heap_base_min_address;
 559       uint64_t unscaled_end = UnscaledOopHeapMax - size;
 560       if (unscaled_end < UnscaledOopHeapMax) { // unscaled_end wrapped if size is large
 561         lowest_start = MAX2(lowest_start, (char*)unscaled_end);
 562       }
 563       lowest_start = align_up(lowest_start, attach_point_alignment);
 564       try_reserve_range(highest_start, lowest_start, attach_point_alignment,
 565                         aligned_heap_base_min_address, zerobased_max, size, alignment, large);
 566     }
 567 
 568     // Now we go for heaps with base != 0.  We need a noaccess prefix to efficiently
 569     // implement null checks.
 570     noaccess_prefix = noaccess_prefix_size(alignment);
 571 
 572     // Try to attach at addresses that are aligned to OopEncodingHeapMax. Disjointbase mode.
 573     char** addresses = get_attach_addresses_for_disjoint_mode();
 574     int i = 0;
 575     while (addresses[i] &&                                 // End of array not yet reached.
 576            ((_base == NULL) ||                             // No previous try succeeded.
 577             (_base + size >  (char *)OopEncodingHeapMax && // Not zerobased or unscaled address.
 578              !CompressedOops::is_disjoint_heap_base_address((address)_base)))) {  // Not disjoint address.
 579       char* const attach_point = addresses[i];
 580       assert(attach_point >= aligned_heap_base_min_address, "Flag support broken");
 581       try_reserve_heap(size + noaccess_prefix, alignment, large, attach_point);
 582       i++;
 583     }
 584 
 585     // Last, desperate try without any placement.
 586     if (_base == NULL) {
 587       log_trace(gc, heap, coops)("Trying to allocate at address NULL heap of size " SIZE_FORMAT_HEX, size + noaccess_prefix);
 588       initialize(size + noaccess_prefix, alignment, large, NULL, false);
 589     }
 590   }
 591 }
 592 
 593 ReservedHeapSpace::ReservedHeapSpace(size_t size, size_t alignment, bool large, const char* heap_allocation_directory) : ReservedSpace() {
 594 
 595   if (size == 0) {
 596     return;
 597   }
 598 
 599   if (heap_allocation_directory != NULL) {
 600     _fd_for_heap = os::create_file_for_heap(heap_allocation_directory);
 601     if (_fd_for_heap == -1) {
 602       vm_exit_during_initialization(
 603         err_msg("Could not create file for Heap at location %s", heap_allocation_directory));
 604     }
 605   }
 606 
 607   // Heap size should be aligned to alignment, too.
 608   guarantee(is_aligned(size, alignment), "set by caller");
 609 
 610   if (UseCompressedOops) {
 611     initialize_compressed_heap(size, alignment, large);
 612     if (_size > size) {
 613       // We allocated heap with noaccess prefix.
 614       // It can happen we get a zerobased/unscaled heap with noaccess prefix,
 615       // if we had to try at arbitrary address.
 616       establish_noaccess_prefix();
 617     }
 618   } else {
 619     initialize(size, alignment, large, NULL, false);
 620   }
 621 
 622   assert(markWord::encode_pointer_as_mark(_base).decode_pointer() == _base,
 623          "area must be distinguishable from marks for mark-sweep");
 624   assert(markWord::encode_pointer_as_mark(&_base[size]).decode_pointer() == &_base[size],
 625          "area must be distinguishable from marks for mark-sweep");
 626 
 627   if (base() != NULL) {
 628     MemTracker::record_virtual_memory_type((address)base(), mtJavaHeap);
 629   }
 630 
 631   if (_fd_for_heap != -1) {
 632     os::close(_fd_for_heap);
 633   }
 634 }
 635 
 636 MemRegion ReservedHeapSpace::region() const {
 637   return MemRegion((HeapWord*)base(), (HeapWord*)end());
 638 }
 639 
 640 // Reserve space for code segment.  Same as Java heap only we mark this as
 641 // executable.
 642 ReservedCodeSpace::ReservedCodeSpace(size_t r_size,
 643                                      size_t rs_align,
 644                                      bool large) : ReservedSpace() {
 645   initialize(r_size, rs_align, large, /*requested address*/ NULL, /*executable*/ true);
 646   MemTracker::record_virtual_memory_type((address)base(), mtCode);
 647 }
 648 
 649 // VirtualSpace
 650 
 651 VirtualSpace::VirtualSpace() {
 652   _low_boundary           = NULL;
 653   _high_boundary          = NULL;
 654   _low                    = NULL;
 655   _high                   = NULL;
 656   _lower_high             = NULL;
 657   _middle_high            = NULL;
 658   _upper_high             = NULL;
 659   _lower_high_boundary    = NULL;
 660   _middle_high_boundary   = NULL;
 661   _upper_high_boundary    = NULL;
 662   _lower_alignment        = 0;
 663   _middle_alignment       = 0;
 664   _upper_alignment        = 0;
 665   _special                = false;
 666   _executable             = false;
 667 }
 668 
 669 
 670 bool VirtualSpace::initialize(ReservedSpace rs, size_t committed_size) {
 671   const size_t max_commit_granularity = os::page_size_for_region_unaligned(rs.size(), 1);
 672   return initialize_with_granularity(rs, committed_size, max_commit_granularity);
 673 }
 674 
 675 bool VirtualSpace::initialize_with_granularity(ReservedSpace rs, size_t committed_size, size_t max_commit_granularity) {
 676   if(!rs.is_reserved()) return false;  // allocation failed.
 677   assert(_low_boundary == NULL, "VirtualSpace already initialized");
 678   assert(max_commit_granularity > 0, "Granularity must be non-zero.");
 679 
 680   _low_boundary  = rs.base();
 681   _high_boundary = low_boundary() + rs.size();
 682 
 683   _low = low_boundary();
 684   _high = low();
 685 
 686   _special = rs.special();
 687   _executable = rs.executable();
 688 
 689   // When a VirtualSpace begins life at a large size, make all future expansion
 690   // and shrinking occur aligned to a granularity of large pages.  This avoids
 691   // fragmentation of physical addresses that inhibits the use of large pages
 692   // by the OS virtual memory system.  Empirically,  we see that with a 4MB
 693   // page size, the only spaces that get handled this way are codecache and
 694   // the heap itself, both of which provide a substantial performance
 695   // boost in many benchmarks when covered by large pages.
 696   //
 697   // No attempt is made to force large page alignment at the very top and
 698   // bottom of the space if they are not aligned so already.
 699   _lower_alignment  = os::vm_page_size();
 700   _middle_alignment = max_commit_granularity;
 701   _upper_alignment  = os::vm_page_size();
 702 
 703   // End of each region
 704   _lower_high_boundary = align_up(low_boundary(), middle_alignment());
 705   _middle_high_boundary = align_down(high_boundary(), middle_alignment());
 706   _upper_high_boundary = high_boundary();
 707 
 708   // High address of each region
 709   _lower_high = low_boundary();
 710   _middle_high = lower_high_boundary();
 711   _upper_high = middle_high_boundary();
 712 
 713   // commit to initial size
 714   if (committed_size > 0) {
 715     if (!expand_by(committed_size)) {
 716       return false;
 717     }
 718   }
 719   return true;
 720 }
 721 
 722 
 723 VirtualSpace::~VirtualSpace() {
 724   release();
 725 }
 726 
 727 
 728 void VirtualSpace::release() {
 729   // This does not release memory it reserved.
 730   // Caller must release via rs.release();
 731   _low_boundary           = NULL;
 732   _high_boundary          = NULL;
 733   _low                    = NULL;
 734   _high                   = NULL;
 735   _lower_high             = NULL;
 736   _middle_high            = NULL;
 737   _upper_high             = NULL;
 738   _lower_high_boundary    = NULL;
 739   _middle_high_boundary   = NULL;
 740   _upper_high_boundary    = NULL;
 741   _lower_alignment        = 0;
 742   _middle_alignment       = 0;
 743   _upper_alignment        = 0;
 744   _special                = false;
 745   _executable             = false;
 746 }
 747 
 748 
 749 size_t VirtualSpace::committed_size() const {
 750   return pointer_delta(high(), low(), sizeof(char));
 751 }
 752 
 753 
 754 size_t VirtualSpace::reserved_size() const {
 755   return pointer_delta(high_boundary(), low_boundary(), sizeof(char));
 756 }
 757 
 758 
 759 size_t VirtualSpace::uncommitted_size()  const {
 760   return reserved_size() - committed_size();
 761 }
 762 
 763 size_t VirtualSpace::actual_committed_size() const {
 764   // Special VirtualSpaces commit all reserved space up front.
 765   if (special()) {
 766     return reserved_size();
 767   }
 768 
 769   size_t committed_low    = pointer_delta(_lower_high,  _low_boundary,         sizeof(char));
 770   size_t committed_middle = pointer_delta(_middle_high, _lower_high_boundary,  sizeof(char));
 771   size_t committed_high   = pointer_delta(_upper_high,  _middle_high_boundary, sizeof(char));
 772 
 773 #ifdef ASSERT
 774   size_t lower  = pointer_delta(_lower_high_boundary,  _low_boundary,         sizeof(char));
 775   size_t middle = pointer_delta(_middle_high_boundary, _lower_high_boundary,  sizeof(char));
 776   size_t upper  = pointer_delta(_upper_high_boundary,  _middle_high_boundary, sizeof(char));
 777 
 778   if (committed_high > 0) {
 779     assert(committed_low == lower, "Must be");
 780     assert(committed_middle == middle, "Must be");
 781   }
 782 
 783   if (committed_middle > 0) {
 784     assert(committed_low == lower, "Must be");
 785   }
 786   if (committed_middle < middle) {
 787     assert(committed_high == 0, "Must be");
 788   }
 789 
 790   if (committed_low < lower) {
 791     assert(committed_high == 0, "Must be");
 792     assert(committed_middle == 0, "Must be");
 793   }
 794 #endif
 795 
 796   return committed_low + committed_middle + committed_high;
 797 }
 798 
 799 
 800 bool VirtualSpace::contains(const void* p) const {
 801   return low() <= (const char*) p && (const char*) p < high();
 802 }
 803 
 804 static void pretouch_expanded_memory(void* start, void* end) {
 805   assert(is_aligned(start, os::vm_page_size()), "Unexpected alignment");
 806   assert(is_aligned(end,   os::vm_page_size()), "Unexpected alignment");
 807 
 808   os::pretouch_memory(start, end);
 809 }
 810 
 811 static bool commit_expanded(char* start, size_t size, size_t alignment, bool pre_touch, bool executable) {
 812   if (os::commit_memory(start, size, alignment, executable)) {
 813     if (pre_touch || AlwaysPreTouch) {
 814       pretouch_expanded_memory(start, start + size);
 815     }
 816     return true;
 817   }
 818 
 819   debug_only(warning(
 820       "INFO: os::commit_memory(" PTR_FORMAT ", " PTR_FORMAT
 821       " size=" SIZE_FORMAT ", executable=%d) failed",
 822       p2i(start), p2i(start + size), size, executable);)
 823 
 824   return false;
 825 }
 826 
 827 /*
 828    First we need to determine if a particular virtual space is using large
 829    pages.  This is done at the initialize function and only virtual spaces
 830    that are larger than LargePageSizeInBytes use large pages.  Once we
 831    have determined this, all expand_by and shrink_by calls must grow and
 832    shrink by large page size chunks.  If a particular request
 833    is within the current large page, the call to commit and uncommit memory
 834    can be ignored.  In the case that the low and high boundaries of this
 835    space is not large page aligned, the pages leading to the first large
 836    page address and the pages after the last large page address must be
 837    allocated with default pages.
 838 */
 839 bool VirtualSpace::expand_by(size_t bytes, bool pre_touch) {
 840   if (uncommitted_size() < bytes) {
 841     return false;
 842   }
 843 
 844   if (special()) {
 845     // don't commit memory if the entire space is pinned in memory
 846     _high += bytes;
 847     return true;
 848   }
 849 
 850   char* previous_high = high();
 851   char* unaligned_new_high = high() + bytes;
 852   assert(unaligned_new_high <= high_boundary(), "cannot expand by more than upper boundary");
 853 
 854   // Calculate where the new high for each of the regions should be.  If
 855   // the low_boundary() and high_boundary() are LargePageSizeInBytes aligned
 856   // then the unaligned lower and upper new highs would be the
 857   // lower_high() and upper_high() respectively.
 858   char* unaligned_lower_new_high =  MIN2(unaligned_new_high, lower_high_boundary());
 859   char* unaligned_middle_new_high = MIN2(unaligned_new_high, middle_high_boundary());
 860   char* unaligned_upper_new_high =  MIN2(unaligned_new_high, upper_high_boundary());
 861 
 862   // Align the new highs based on the regions alignment.  lower and upper
 863   // alignment will always be default page size.  middle alignment will be
 864   // LargePageSizeInBytes if the actual size of the virtual space is in
 865   // fact larger than LargePageSizeInBytes.
 866   char* aligned_lower_new_high =  align_up(unaligned_lower_new_high, lower_alignment());
 867   char* aligned_middle_new_high = align_up(unaligned_middle_new_high, middle_alignment());
 868   char* aligned_upper_new_high =  align_up(unaligned_upper_new_high, upper_alignment());
 869 
 870   // Determine which regions need to grow in this expand_by call.
 871   // If you are growing in the lower region, high() must be in that
 872   // region so calculate the size based on high().  For the middle and
 873   // upper regions, determine the starting point of growth based on the
 874   // location of high().  By getting the MAX of the region's low address
 875   // (or the previous region's high address) and high(), we can tell if it
 876   // is an intra or inter region growth.
 877   size_t lower_needs = 0;
 878   if (aligned_lower_new_high > lower_high()) {
 879     lower_needs = pointer_delta(aligned_lower_new_high, lower_high(), sizeof(char));
 880   }
 881   size_t middle_needs = 0;
 882   if (aligned_middle_new_high > middle_high()) {
 883     middle_needs = pointer_delta(aligned_middle_new_high, middle_high(), sizeof(char));
 884   }
 885   size_t upper_needs = 0;
 886   if (aligned_upper_new_high > upper_high()) {
 887     upper_needs = pointer_delta(aligned_upper_new_high, upper_high(), sizeof(char));
 888   }
 889 
 890   // Check contiguity.
 891   assert(low_boundary() <= lower_high() && lower_high() <= lower_high_boundary(),
 892          "high address must be contained within the region");
 893   assert(lower_high_boundary() <= middle_high() && middle_high() <= middle_high_boundary(),
 894          "high address must be contained within the region");
 895   assert(middle_high_boundary() <= upper_high() && upper_high() <= upper_high_boundary(),
 896          "high address must be contained within the region");
 897 
 898   // Commit regions
 899   if (lower_needs > 0) {
 900     assert(lower_high() + lower_needs <= lower_high_boundary(), "must not expand beyond region");
 901     if (!commit_expanded(lower_high(), lower_needs, _lower_alignment, pre_touch, _executable)) {
 902       return false;
 903     }
 904     _lower_high += lower_needs;
 905   }
 906 
 907   if (middle_needs > 0) {
 908     assert(middle_high() + middle_needs <= middle_high_boundary(), "must not expand beyond region");
 909     if (!commit_expanded(middle_high(), middle_needs, _middle_alignment, pre_touch, _executable)) {
 910       return false;
 911     }
 912     _middle_high += middle_needs;
 913   }
 914 
 915   if (upper_needs > 0) {
 916     assert(upper_high() + upper_needs <= upper_high_boundary(), "must not expand beyond region");
 917     if (!commit_expanded(upper_high(), upper_needs, _upper_alignment, pre_touch, _executable)) {
 918       return false;
 919     }
 920     _upper_high += upper_needs;
 921   }
 922 
 923   _high += bytes;
 924   return true;
 925 }
 926 
 927 // A page is uncommitted if the contents of the entire page is deemed unusable.
 928 // Continue to decrement the high() pointer until it reaches a page boundary
 929 // in which case that particular page can now be uncommitted.
 930 void VirtualSpace::shrink_by(size_t size) {
 931   if (committed_size() < size)
 932     fatal("Cannot shrink virtual space to negative size");
 933 
 934   if (special()) {
 935     // don't uncommit if the entire space is pinned in memory
 936     _high -= size;
 937     return;
 938   }
 939 
 940   char* unaligned_new_high = high() - size;
 941   assert(unaligned_new_high >= low_boundary(), "cannot shrink past lower boundary");
 942 
 943   // Calculate new unaligned address
 944   char* unaligned_upper_new_high =
 945     MAX2(unaligned_new_high, middle_high_boundary());
 946   char* unaligned_middle_new_high =
 947     MAX2(unaligned_new_high, lower_high_boundary());
 948   char* unaligned_lower_new_high =
 949     MAX2(unaligned_new_high, low_boundary());
 950 
 951   // Align address to region's alignment
 952   char* aligned_upper_new_high =  align_up(unaligned_upper_new_high, upper_alignment());
 953   char* aligned_middle_new_high = align_up(unaligned_middle_new_high, middle_alignment());
 954   char* aligned_lower_new_high =  align_up(unaligned_lower_new_high, lower_alignment());
 955 
 956   // Determine which regions need to shrink
 957   size_t upper_needs = 0;
 958   if (aligned_upper_new_high < upper_high()) {
 959     upper_needs =
 960       pointer_delta(upper_high(), aligned_upper_new_high, sizeof(char));
 961   }
 962   size_t middle_needs = 0;
 963   if (aligned_middle_new_high < middle_high()) {
 964     middle_needs =
 965       pointer_delta(middle_high(), aligned_middle_new_high, sizeof(char));
 966   }
 967   size_t lower_needs = 0;
 968   if (aligned_lower_new_high < lower_high()) {
 969     lower_needs =
 970       pointer_delta(lower_high(), aligned_lower_new_high, sizeof(char));
 971   }
 972 
 973   // Check contiguity.
 974   assert(middle_high_boundary() <= upper_high() &&
 975          upper_high() <= upper_high_boundary(),
 976          "high address must be contained within the region");
 977   assert(lower_high_boundary() <= middle_high() &&
 978          middle_high() <= middle_high_boundary(),
 979          "high address must be contained within the region");
 980   assert(low_boundary() <= lower_high() &&
 981          lower_high() <= lower_high_boundary(),
 982          "high address must be contained within the region");
 983 
 984   // Uncommit
 985   if (upper_needs > 0) {
 986     assert(middle_high_boundary() <= aligned_upper_new_high &&
 987            aligned_upper_new_high + upper_needs <= upper_high_boundary(),
 988            "must not shrink beyond region");
 989     if (!os::uncommit_memory(aligned_upper_new_high, upper_needs)) {
 990       debug_only(warning("os::uncommit_memory failed"));
 991       return;
 992     } else {
 993       _upper_high -= upper_needs;
 994     }
 995   }
 996   if (middle_needs > 0) {
 997     assert(lower_high_boundary() <= aligned_middle_new_high &&
 998            aligned_middle_new_high + middle_needs <= middle_high_boundary(),
 999            "must not shrink beyond region");
1000     if (!os::uncommit_memory(aligned_middle_new_high, middle_needs)) {
1001       debug_only(warning("os::uncommit_memory failed"));
1002       return;
1003     } else {
1004       _middle_high -= middle_needs;
1005     }
1006   }
1007   if (lower_needs > 0) {
1008     assert(low_boundary() <= aligned_lower_new_high &&
1009            aligned_lower_new_high + lower_needs <= lower_high_boundary(),
1010            "must not shrink beyond region");
1011     if (!os::uncommit_memory(aligned_lower_new_high, lower_needs)) {
1012       debug_only(warning("os::uncommit_memory failed"));
1013       return;
1014     } else {
1015       _lower_high -= lower_needs;
1016     }
1017   }
1018 
1019   _high -= size;
1020 }
1021 
1022 #ifndef PRODUCT
1023 void VirtualSpace::check_for_contiguity() {
1024   // Check contiguity.
1025   assert(low_boundary() <= lower_high() &&
1026          lower_high() <= lower_high_boundary(),
1027          "high address must be contained within the region");
1028   assert(lower_high_boundary() <= middle_high() &&
1029          middle_high() <= middle_high_boundary(),
1030          "high address must be contained within the region");
1031   assert(middle_high_boundary() <= upper_high() &&
1032          upper_high() <= upper_high_boundary(),
1033          "high address must be contained within the region");
1034   assert(low() >= low_boundary(), "low");
1035   assert(low_boundary() <= lower_high_boundary(), "lower high boundary");
1036   assert(upper_high_boundary() <= high_boundary(), "upper high boundary");
1037   assert(high() <= upper_high(), "upper high");
1038 }
1039 
1040 void VirtualSpace::print_on(outputStream* out) {
1041   out->print   ("Virtual space:");
1042   if (special()) out->print(" (pinned in memory)");
1043   out->cr();
1044   out->print_cr(" - committed: " SIZE_FORMAT, committed_size());
1045   out->print_cr(" - reserved:  " SIZE_FORMAT, reserved_size());
1046   out->print_cr(" - [low, high]:     [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",  p2i(low()), p2i(high()));
1047   out->print_cr(" - [low_b, high_b]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",  p2i(low_boundary()), p2i(high_boundary()));
1048 }
1049 
1050 void VirtualSpace::print() {
1051   print_on(tty);
1052 }
1053 
1054 /////////////// Unit tests ///////////////
1055 
1056 #ifndef PRODUCT
1057 
1058 class TestReservedSpace : AllStatic {
1059  public:
1060   static void small_page_write(void* addr, size_t size) {
1061     size_t page_size = os::vm_page_size();
1062 
1063     char* end = (char*)addr + size;
1064     for (char* p = (char*)addr; p < end; p += page_size) {
1065       *p = 1;
1066     }
1067   }
1068 
1069   static void release_memory_for_test(ReservedSpace rs) {
1070     if (rs.special()) {
1071       guarantee(os::release_memory_special(rs.base(), rs.size()), "Shouldn't fail");
1072     } else {
1073       guarantee(os::release_memory(rs.base(), rs.size()), "Shouldn't fail");
1074     }
1075   }
1076 
1077   static void test_reserved_space1(size_t size, size_t alignment) {
1078     assert(is_aligned(size, alignment), "Incorrect input parameters");
1079 
1080     ReservedSpace rs(size,          // size
1081                      alignment,     // alignment
1082                      UseLargePages, // large
1083                      (char *)NULL); // requested_address
1084 
1085     assert(rs.base() != NULL, "Must be");
1086     assert(rs.size() == size, "Must be");
1087 
1088     assert(is_aligned(rs.base(), alignment), "aligned sizes should always give aligned addresses");
1089     assert(is_aligned(rs.size(), alignment), "aligned sizes should always give aligned addresses");
1090 
1091     if (rs.special()) {
1092       small_page_write(rs.base(), size);
1093     }
1094 
1095     release_memory_for_test(rs);
1096   }
1097 
1098   static void test_reserved_space2(size_t size) {
1099     assert(is_aligned(size, os::vm_allocation_granularity()), "Must be at least AG aligned");
1100 
1101     ReservedSpace rs(size);
1102 
1103     assert(rs.base() != NULL, "Must be");
1104     assert(rs.size() == size, "Must be");
1105 
1106     if (rs.special()) {
1107       small_page_write(rs.base(), size);
1108     }
1109 
1110     release_memory_for_test(rs);
1111   }
1112 
1113   static void test_reserved_space3(size_t size, size_t alignment, bool maybe_large) {
1114     if (size < alignment) {
1115       // Tests might set -XX:LargePageSizeInBytes=<small pages> and cause unexpected input arguments for this test.
1116       assert((size_t)os::vm_page_size() == os::large_page_size(), "Test needs further refinement");
1117       return;
1118     }
1119 
1120     assert(is_aligned(size, os::vm_allocation_granularity()), "Must be at least AG aligned");
1121     assert(is_aligned(size, alignment), "Must be at least aligned against alignment");
1122 
1123     bool large = maybe_large && UseLargePages && size >= os::large_page_size();
1124 
1125     ReservedSpace rs(size, alignment, large);
1126 
1127     assert(rs.base() != NULL, "Must be");
1128     assert(rs.size() == size, "Must be");
1129 
1130     if (rs.special()) {
1131       small_page_write(rs.base(), size);
1132     }
1133 
1134     release_memory_for_test(rs);
1135   }
1136 
1137 
1138   static void test_reserved_space1() {
1139     size_t size = 2 * 1024 * 1024;
1140     size_t ag   = os::vm_allocation_granularity();
1141 
1142     test_reserved_space1(size,      ag);
1143     test_reserved_space1(size * 2,  ag);
1144     test_reserved_space1(size * 10, ag);
1145   }
1146 
1147   static void test_reserved_space2() {
1148     size_t size = 2 * 1024 * 1024;
1149     size_t ag = os::vm_allocation_granularity();
1150 
1151     test_reserved_space2(size * 1);
1152     test_reserved_space2(size * 2);
1153     test_reserved_space2(size * 10);
1154     test_reserved_space2(ag);
1155     test_reserved_space2(size - ag);
1156     test_reserved_space2(size);
1157     test_reserved_space2(size + ag);
1158     test_reserved_space2(size * 2);
1159     test_reserved_space2(size * 2 - ag);
1160     test_reserved_space2(size * 2 + ag);
1161     test_reserved_space2(size * 3);
1162     test_reserved_space2(size * 3 - ag);
1163     test_reserved_space2(size * 3 + ag);
1164     test_reserved_space2(size * 10);
1165     test_reserved_space2(size * 10 + size / 2);
1166   }
1167 
1168   static void test_reserved_space3() {
1169     size_t ag = os::vm_allocation_granularity();
1170 
1171     test_reserved_space3(ag,      ag    , false);
1172     test_reserved_space3(ag * 2,  ag    , false);
1173     test_reserved_space3(ag * 3,  ag    , false);
1174     test_reserved_space3(ag * 2,  ag * 2, false);
1175     test_reserved_space3(ag * 4,  ag * 2, false);
1176     test_reserved_space3(ag * 8,  ag * 2, false);
1177     test_reserved_space3(ag * 4,  ag * 4, false);
1178     test_reserved_space3(ag * 8,  ag * 4, false);
1179     test_reserved_space3(ag * 16, ag * 4, false);
1180 
1181     if (UseLargePages) {
1182       size_t lp = os::large_page_size();
1183 
1184       // Without large pages
1185       test_reserved_space3(lp,     ag * 4, false);
1186       test_reserved_space3(lp * 2, ag * 4, false);
1187       test_reserved_space3(lp * 4, ag * 4, false);
1188       test_reserved_space3(lp,     lp    , false);
1189       test_reserved_space3(lp * 2, lp    , false);
1190       test_reserved_space3(lp * 3, lp    , false);
1191       test_reserved_space3(lp * 2, lp * 2, false);
1192       test_reserved_space3(lp * 4, lp * 2, false);
1193       test_reserved_space3(lp * 8, lp * 2, false);
1194 
1195       // With large pages
1196       test_reserved_space3(lp, ag * 4    , true);
1197       test_reserved_space3(lp * 2, ag * 4, true);
1198       test_reserved_space3(lp * 4, ag * 4, true);
1199       test_reserved_space3(lp, lp        , true);
1200       test_reserved_space3(lp * 2, lp    , true);
1201       test_reserved_space3(lp * 3, lp    , true);
1202       test_reserved_space3(lp * 2, lp * 2, true);
1203       test_reserved_space3(lp * 4, lp * 2, true);
1204       test_reserved_space3(lp * 8, lp * 2, true);
1205     }
1206   }
1207 
1208   static void test_reserved_space() {
1209     test_reserved_space1();
1210     test_reserved_space2();
1211     test_reserved_space3();
1212   }
1213 };
1214 
1215 void TestReservedSpace_test() {
1216   TestReservedSpace::test_reserved_space();
1217 }
1218 
1219 #define assert_equals(actual, expected)  \
1220   assert(actual == expected,             \
1221          "Got " SIZE_FORMAT " expected " \
1222          SIZE_FORMAT, actual, expected);
1223 
1224 #define assert_ge(value1, value2)                  \
1225   assert(value1 >= value2,                         \
1226          "'" #value1 "': " SIZE_FORMAT " '"        \
1227          #value2 "': " SIZE_FORMAT, value1, value2);
1228 
1229 #define assert_lt(value1, value2)                  \
1230   assert(value1 < value2,                          \
1231          "'" #value1 "': " SIZE_FORMAT " '"        \
1232          #value2 "': " SIZE_FORMAT, value1, value2);
1233 
1234 
1235 class TestVirtualSpace : AllStatic {
1236   enum TestLargePages {
1237     Default,
1238     Disable,
1239     Reserve,
1240     Commit
1241   };
1242 
1243   static ReservedSpace reserve_memory(size_t reserve_size_aligned, TestLargePages mode) {
1244     switch(mode) {
1245     default:
1246     case Default:
1247     case Reserve:
1248       return ReservedSpace(reserve_size_aligned);
1249     case Disable:
1250     case Commit:
1251       return ReservedSpace(reserve_size_aligned,
1252                            os::vm_allocation_granularity(),
1253                            /* large */ false);
1254     }
1255   }
1256 
1257   static bool initialize_virtual_space(VirtualSpace& vs, ReservedSpace rs, TestLargePages mode) {
1258     switch(mode) {
1259     default:
1260     case Default:
1261     case Reserve:
1262       return vs.initialize(rs, 0);
1263     case Disable:
1264       return vs.initialize_with_granularity(rs, 0, os::vm_page_size());
1265     case Commit:
1266       return vs.initialize_with_granularity(rs, 0, os::page_size_for_region_unaligned(rs.size(), 1));
1267     }
1268   }
1269 
1270  public:
1271   static void test_virtual_space_actual_committed_space(size_t reserve_size, size_t commit_size,
1272                                                         TestLargePages mode = Default) {
1273     size_t granularity = os::vm_allocation_granularity();
1274     size_t reserve_size_aligned = align_up(reserve_size, granularity);
1275 
1276     ReservedSpace reserved = reserve_memory(reserve_size_aligned, mode);
1277 
1278     assert(reserved.is_reserved(), "Must be");
1279 
1280     VirtualSpace vs;
1281     bool initialized = initialize_virtual_space(vs, reserved, mode);
1282     assert(initialized, "Failed to initialize VirtualSpace");
1283 
1284     vs.expand_by(commit_size, false);
1285 
1286     if (vs.special()) {
1287       assert_equals(vs.actual_committed_size(), reserve_size_aligned);
1288     } else {
1289       assert_ge(vs.actual_committed_size(), commit_size);
1290       // Approximate the commit granularity.
1291       // Make sure that we don't commit using large pages
1292       // if large pages has been disabled for this VirtualSpace.
1293       size_t commit_granularity = (mode == Disable || !UseLargePages) ?
1294                                    os::vm_page_size() : os::large_page_size();
1295       assert_lt(vs.actual_committed_size(), commit_size + commit_granularity);
1296     }
1297 
1298     reserved.release();
1299   }
1300 
1301   static void test_virtual_space_actual_committed_space_one_large_page() {
1302     if (!UseLargePages) {
1303       return;
1304     }
1305 
1306     size_t large_page_size = os::large_page_size();
1307 
1308     ReservedSpace reserved(large_page_size, large_page_size, true);
1309 
1310     assert(reserved.is_reserved(), "Must be");
1311 
1312     VirtualSpace vs;
1313     bool initialized = vs.initialize(reserved, 0);
1314     assert(initialized, "Failed to initialize VirtualSpace");
1315 
1316     vs.expand_by(large_page_size, false);
1317 
1318     assert_equals(vs.actual_committed_size(), large_page_size);
1319 
1320     reserved.release();
1321   }
1322 
1323   static void test_virtual_space_actual_committed_space() {
1324     test_virtual_space_actual_committed_space(4 * K, 0);
1325     test_virtual_space_actual_committed_space(4 * K, 4 * K);
1326     test_virtual_space_actual_committed_space(8 * K, 0);
1327     test_virtual_space_actual_committed_space(8 * K, 4 * K);
1328     test_virtual_space_actual_committed_space(8 * K, 8 * K);
1329     test_virtual_space_actual_committed_space(12 * K, 0);
1330     test_virtual_space_actual_committed_space(12 * K, 4 * K);
1331     test_virtual_space_actual_committed_space(12 * K, 8 * K);
1332     test_virtual_space_actual_committed_space(12 * K, 12 * K);
1333     test_virtual_space_actual_committed_space(64 * K, 0);
1334     test_virtual_space_actual_committed_space(64 * K, 32 * K);
1335     test_virtual_space_actual_committed_space(64 * K, 64 * K);
1336     test_virtual_space_actual_committed_space(2 * M, 0);
1337     test_virtual_space_actual_committed_space(2 * M, 4 * K);
1338     test_virtual_space_actual_committed_space(2 * M, 64 * K);
1339     test_virtual_space_actual_committed_space(2 * M, 1 * M);
1340     test_virtual_space_actual_committed_space(2 * M, 2 * M);
1341     test_virtual_space_actual_committed_space(10 * M, 0);
1342     test_virtual_space_actual_committed_space(10 * M, 4 * K);
1343     test_virtual_space_actual_committed_space(10 * M, 8 * K);
1344     test_virtual_space_actual_committed_space(10 * M, 1 * M);
1345     test_virtual_space_actual_committed_space(10 * M, 2 * M);
1346     test_virtual_space_actual_committed_space(10 * M, 5 * M);
1347     test_virtual_space_actual_committed_space(10 * M, 10 * M);
1348   }
1349 
1350   static void test_virtual_space_disable_large_pages() {
1351     if (!UseLargePages) {
1352       return;
1353     }
1354     // These test cases verify that if we force VirtualSpace to disable large pages
1355     test_virtual_space_actual_committed_space(10 * M, 0, Disable);
1356     test_virtual_space_actual_committed_space(10 * M, 4 * K, Disable);
1357     test_virtual_space_actual_committed_space(10 * M, 8 * K, Disable);
1358     test_virtual_space_actual_committed_space(10 * M, 1 * M, Disable);
1359     test_virtual_space_actual_committed_space(10 * M, 2 * M, Disable);
1360     test_virtual_space_actual_committed_space(10 * M, 5 * M, Disable);
1361     test_virtual_space_actual_committed_space(10 * M, 10 * M, Disable);
1362 
1363     test_virtual_space_actual_committed_space(10 * M, 0, Reserve);
1364     test_virtual_space_actual_committed_space(10 * M, 4 * K, Reserve);
1365     test_virtual_space_actual_committed_space(10 * M, 8 * K, Reserve);
1366     test_virtual_space_actual_committed_space(10 * M, 1 * M, Reserve);
1367     test_virtual_space_actual_committed_space(10 * M, 2 * M, Reserve);
1368     test_virtual_space_actual_committed_space(10 * M, 5 * M, Reserve);
1369     test_virtual_space_actual_committed_space(10 * M, 10 * M, Reserve);
1370 
1371     test_virtual_space_actual_committed_space(10 * M, 0, Commit);
1372     test_virtual_space_actual_committed_space(10 * M, 4 * K, Commit);
1373     test_virtual_space_actual_committed_space(10 * M, 8 * K, Commit);
1374     test_virtual_space_actual_committed_space(10 * M, 1 * M, Commit);
1375     test_virtual_space_actual_committed_space(10 * M, 2 * M, Commit);
1376     test_virtual_space_actual_committed_space(10 * M, 5 * M, Commit);
1377     test_virtual_space_actual_committed_space(10 * M, 10 * M, Commit);
1378   }
1379 
1380   static void test_virtual_space() {
1381     test_virtual_space_actual_committed_space();
1382     test_virtual_space_actual_committed_space_one_large_page();
1383     test_virtual_space_disable_large_pages();
1384   }
1385 };
1386 
1387 void TestVirtualSpace_test() {
1388   TestVirtualSpace::test_virtual_space();
1389 }
1390 
1391 #endif // PRODUCT
1392 
1393 #endif
--- EOF ---