Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/src/share/vm/runtime/virtualspace.cpp	Wed Apr 24 20:13:37 2013 +0200
     1.2 +++ b/src/share/vm/runtime/virtualspace.cpp	Fri Apr 26 09:53:22 2013 +0200
     1.3 @@ -60,72 +60,6 @@
     1.4    initialize(size, alignment, large, NULL, 0, executable);
     1.5  }
     1.6  
     1.7 -char *
     1.8 -ReservedSpace::align_reserved_region(char* addr, const size_t len,
     1.9 -                                     const size_t prefix_size,
    1.10 -                                     const size_t prefix_align,
    1.11 -                                     const size_t suffix_size,
    1.12 -                                     const size_t suffix_align)
    1.13 -{
    1.14 -  assert(addr != NULL, "sanity");
    1.15 -  const size_t required_size = prefix_size + suffix_size;
    1.16 -  assert(len >= required_size, "len too small");
    1.17 -
    1.18 -  const size_t s = size_t(addr);
    1.19 -  const size_t beg_ofs = (s + prefix_size) & (suffix_align - 1);
    1.20 -  const size_t beg_delta = beg_ofs == 0 ? 0 : suffix_align - beg_ofs;
    1.21 -
    1.22 -  if (len < beg_delta + required_size) {
    1.23 -     return NULL; // Cannot do proper alignment.
    1.24 -  }
    1.25 -  const size_t end_delta = len - (beg_delta + required_size);
    1.26 -
    1.27 -  if (beg_delta != 0) {
    1.28 -    os::release_memory(addr, beg_delta);
    1.29 -  }
    1.30 -
    1.31 -  if (end_delta != 0) {
    1.32 -    char* release_addr = (char*) (s + beg_delta + required_size);
    1.33 -    os::release_memory(release_addr, end_delta);
    1.34 -  }
    1.35 -
    1.36 -  return (char*) (s + beg_delta);
    1.37 -}
    1.38 -
    1.39 -char* ReservedSpace::reserve_and_align(const size_t reserve_size,
    1.40 -                                       const size_t prefix_size,
    1.41 -                                       const size_t prefix_align,
    1.42 -                                       const size_t suffix_size,
    1.43 -                                       const size_t suffix_align)
    1.44 -{
    1.45 -  assert(reserve_size > prefix_size + suffix_size, "should not be here");
    1.46 -
    1.47 -  char* raw_addr = os::reserve_memory(reserve_size, NULL, prefix_align);
    1.48 -  if (raw_addr == NULL) return NULL;
    1.49 -
    1.50 -  char* result = align_reserved_region(raw_addr, reserve_size, prefix_size,
    1.51 -                                       prefix_align, suffix_size,
    1.52 -                                       suffix_align);
    1.53 -  if (result == NULL && !os::release_memory(raw_addr, reserve_size)) {
    1.54 -    fatal("os::release_memory failed");
    1.55 -  }
    1.56 -
    1.57 -#ifdef ASSERT
    1.58 -  if (result != NULL) {
    1.59 -    const size_t raw = size_t(raw_addr);
    1.60 -    const size_t res = size_t(result);
    1.61 -    assert(res >= raw, "alignment decreased start addr");
    1.62 -    assert(res + prefix_size + suffix_size <= raw + reserve_size,
    1.63 -           "alignment increased end addr");
    1.64 -    assert((res & (prefix_align - 1)) == 0, "bad alignment of prefix");
    1.65 -    assert(((res + prefix_size) & (suffix_align - 1)) == 0,
    1.66 -           "bad alignment of suffix");
    1.67 -  }
    1.68 -#endif
    1.69 -
    1.70 -  return result;
    1.71 -}
    1.72 -
    1.73  // Helper method.
    1.74  static bool failed_to_reserve_as_requested(char* base, char* requested_address,
    1.75                                             const size_t size, bool special)
    1.76 @@ -155,92 +89,6 @@
    1.77    return true;
    1.78  }
    1.79  
    1.80 -ReservedSpace::ReservedSpace(const size_t suffix_size,
    1.81 -                             const size_t suffix_align,
    1.82 -                             char* requested_address,
    1.83 -                             const size_t noaccess_prefix)
    1.84 -{
    1.85 -  assert(suffix_size != 0, "sanity");
    1.86 -  assert(suffix_align != 0, "sanity");
    1.87 -  assert((suffix_size & (suffix_align - 1)) == 0,
    1.88 -    "suffix_size not divisible by suffix_align");
    1.89 -
    1.90 -  // Assert that if noaccess_prefix is used, it is the same as prefix_align.
    1.91 -  // Add in noaccess_prefix to prefix
    1.92 -  const size_t adjusted_prefix_size = noaccess_prefix;
    1.93 -  const size_t size = adjusted_prefix_size + suffix_size;
    1.94 -
    1.95 -  // On systems where the entire region has to be reserved and committed up
    1.96 -  // front, the compound alignment normally done by this method is unnecessary.
    1.97 -  const bool try_reserve_special = UseLargePages &&
    1.98 -    suffix_align == os::large_page_size();
    1.99 -  if (!os::can_commit_large_page_memory() && try_reserve_special) {
   1.100 -    initialize(size, suffix_align, true, requested_address, noaccess_prefix,
   1.101 -               false);
   1.102 -    return;
   1.103 -  }
   1.104 -
   1.105 -  _base = NULL;
   1.106 -  _size = 0;
   1.107 -  _alignment = 0;
   1.108 -  _special = false;
   1.109 -  _noaccess_prefix = 0;
   1.110 -  _executable = false;
   1.111 -
   1.112 -  // Optimistically try to reserve the exact size needed.
   1.113 -  char* addr;
   1.114 -  if (requested_address != 0) {
   1.115 -    requested_address -= noaccess_prefix; // adjust address
   1.116 -    assert(requested_address != NULL, "huge noaccess prefix?");
   1.117 -    addr = os::attempt_reserve_memory_at(size, requested_address);
   1.118 -    if (failed_to_reserve_as_requested(addr, requested_address, size, false)) {
   1.119 -      // OS ignored requested address. Try different address.
   1.120 -      addr = NULL;
   1.121 -    }
   1.122 -  } else {
   1.123 -    addr = os::reserve_memory(size, NULL, suffix_align);
   1.124 -  }
   1.125 -  if (addr == NULL) return;
   1.126 -
   1.127 -  // Check whether the result has the needed alignment
   1.128 -  const size_t ofs = (size_t(addr) + adjusted_prefix_size) & (suffix_align - 1);
   1.129 -  if (ofs != 0) {
   1.130 -    // Wrong alignment.  Release, allocate more space and do manual alignment.
   1.131 -    //
   1.132 -    // On most operating systems, another allocation with a somewhat larger size
   1.133 -    // will return an address "close to" that of the previous allocation.  The
   1.134 -    // result is often the same address (if the kernel hands out virtual
   1.135 -    // addresses from low to high), or an address that is offset by the increase
   1.136 -    // in size.  Exploit that to minimize the amount of extra space requested.
   1.137 -    if (!os::release_memory(addr, size)) {
   1.138 -      fatal("os::release_memory failed");
   1.139 -    }
   1.140 -
   1.141 -    const size_t extra = MAX2(ofs, suffix_align - ofs);
   1.142 -    addr = reserve_and_align(size + extra, adjusted_prefix_size, suffix_align,
   1.143 -                             suffix_size, suffix_align);
   1.144 -    if (addr == NULL) {
   1.145 -      // Try an even larger region.  If this fails, address space is exhausted.
   1.146 -      addr = reserve_and_align(size + suffix_align, adjusted_prefix_size,
   1.147 -                               suffix_align, suffix_size, suffix_align);
   1.148 -    }
   1.149 -
   1.150 -    if (requested_address != 0 &&
   1.151 -        failed_to_reserve_as_requested(addr, requested_address, size, false)) {
   1.152 -      // As a result of the alignment constraints, the allocated addr differs
   1.153 -      // from the requested address. Return back to the caller who can
   1.154 -      // take remedial action (like try again without a requested address).
   1.155 -      assert(_base == NULL, "should be");
   1.156 -      return;
   1.157 -    }
   1.158 -  }
   1.159 -
   1.160 -  _base = addr;
   1.161 -  _size = size;
   1.162 -  _alignment = suffix_align;
   1.163 -  _noaccess_prefix = noaccess_prefix;
   1.164 -}
   1.165 -
   1.166  void ReservedSpace::initialize(size_t size, size_t alignment, bool large,
   1.167                                 char* requested_address,
   1.168                                 const size_t noaccess_prefix,
   1.169 @@ -476,20 +324,6 @@
   1.170    protect_noaccess_prefix(size);
   1.171  }
   1.172  
   1.173 -ReservedHeapSpace::ReservedHeapSpace(const size_t heap_space_size,
   1.174 -                                     const size_t alignment,
   1.175 -                                     char* requested_address) :
   1.176 -  ReservedSpace(heap_space_size, alignment,
   1.177 -                requested_address,
   1.178 -                (UseCompressedOops && (Universe::narrow_oop_base() != NULL) &&
   1.179 -                 Universe::narrow_oop_use_implicit_null_checks()) ?
   1.180 -                  lcm(os::vm_page_size(), alignment) : 0) {
   1.181 -  if (base() > 0) {
   1.182 -    MemTracker::record_virtual_memory_type((address)base(), mtJavaHeap);
   1.183 -  }
   1.184 -  protect_noaccess_prefix(heap_space_size);
   1.185 -}
   1.186 -
   1.187  // Reserve space for code segment.  Same as Java heap only we mark this as
   1.188  // executable.
   1.189  ReservedCodeSpace::ReservedCodeSpace(size_t r_size,

     2.1 --- a/src/share/vm/runtime/virtualspace.hpp	Wed Apr 24 20:13:37 2013 +0200
     2.2 +++ b/src/share/vm/runtime/virtualspace.hpp	Fri Apr 26 09:53:22 2013 +0200
     2.3 @@ -47,28 +47,6 @@
     2.4                    const size_t noaccess_prefix,
     2.5                    bool executable);
     2.6  
     2.7 -  // Release parts of an already-reserved memory region [addr, addr + len) to
     2.8 -  // get a new region that has "compound alignment."  Return the start of the
     2.9 -  // resulting region, or NULL on failure.
    2.10 -  //
    2.11 -  // The region is logically divided into a prefix and a suffix.  The prefix
    2.12 -  // starts at the result address, which is aligned to prefix_align.  The suffix
    2.13 -  // starts at result address + prefix_size, which is aligned to suffix_align.
    2.14 -  // The total size of the result region is size prefix_size + suffix_size.
    2.15 -  char* align_reserved_region(char* addr, const size_t len,
    2.16 -                              const size_t prefix_size,
    2.17 -                              const size_t prefix_align,
    2.18 -                              const size_t suffix_size,
    2.19 -                              const size_t suffix_align);
    2.20 -
    2.21 -  // Reserve memory, call align_reserved_region() to alignment it and return the
    2.22 -  // result.
    2.23 -  char* reserve_and_align(const size_t reserve_size,
    2.24 -                          const size_t prefix_size,
    2.25 -                          const size_t prefix_align,
    2.26 -                          const size_t suffix_size,
    2.27 -                          const size_t suffix_align);
    2.28 -
    2.29   protected:
    2.30    // Create protection page at the beginning of the space.
    2.31    void protect_noaccess_prefix(const size_t size);
    2.32 @@ -79,9 +57,6 @@
    2.33    ReservedSpace(size_t size, size_t alignment, bool large,
    2.34                  char* requested_address = NULL,
    2.35                  const size_t noaccess_prefix = 0);
    2.36 -  ReservedSpace(const size_t suffix_size, const size_t suffix_align,
    2.37 -                char* requested_address,
    2.38 -                const size_t noaccess_prefix = 0);
    2.39    ReservedSpace(size_t size, size_t alignment, bool large, bool executable);
    2.40  
    2.41    // Accessors
    2.42 @@ -128,8 +103,6 @@
    2.43    // Constructor
    2.44    ReservedHeapSpace(size_t size, size_t forced_base_alignment,
    2.45                      bool large, char* requested_address);
    2.46 -  ReservedHeapSpace(const size_t prefix_size, const size_t prefix_align,
    2.47 -                    char* requested_address);
    2.48  };
    2.49  
    2.50  // Class encapsulating behavior specific memory space for Code