hotspot/src/share/vm/runtime/virtualspace.cpp
author stefank
Tue, 23 Nov 2010 13:22:55 -0800
changeset 7397 5b173b4ca846
parent 5898 7f882d601e07
child 10237 df347ffafa0d
permissions -rw-r--r--
6989984: Use standard include model for Hospot Summary: Replaced MakeDeps and the includeDB files with more standardized solutions. Reviewed-by: coleenp, kvn, kamg
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
     2
 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3261
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    26
#include "oops/markOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    27
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    28
#include "runtime/virtualspace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    29
#ifdef TARGET_OS_FAMILY_linux
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    30
# include "os_linux.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    31
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    32
#ifdef TARGET_OS_FAMILY_solaris
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    33
# include "os_solaris.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    34
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    35
#ifdef TARGET_OS_FAMILY_windows
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    36
# include "os_windows.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5898
diff changeset
    37
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// ReservedSpace
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
ReservedSpace::ReservedSpace(size_t size) {
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
    42
  initialize(size, 0, false, NULL, 0, false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
ReservedSpace::ReservedSpace(size_t size, size_t alignment,
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
    46
                             bool large,
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
    47
                             char* requested_address,
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
    48
                             const size_t noaccess_prefix) {
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
    49
  initialize(size+noaccess_prefix, alignment, large, requested_address,
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
    50
             noaccess_prefix, false);
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
    51
}
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
    52
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
    53
ReservedSpace::ReservedSpace(size_t size, size_t alignment,
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
    54
                             bool large,
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
    55
                             bool executable) {
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
    56
  initialize(size, alignment, large, NULL, 0, executable);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
char *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
ReservedSpace::align_reserved_region(char* addr, const size_t len,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
                                     const size_t prefix_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
                                     const size_t prefix_align,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
                                     const size_t suffix_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
                                     const size_t suffix_align)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  assert(addr != NULL, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  const size_t required_size = prefix_size + suffix_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  assert(len >= required_size, "len too small");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  const size_t s = size_t(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  const size_t beg_ofs = s + prefix_size & suffix_align - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  const size_t beg_delta = beg_ofs == 0 ? 0 : suffix_align - beg_ofs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  if (len < beg_delta + required_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
     return NULL; // Cannot do proper alignment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  const size_t end_delta = len - (beg_delta + required_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  if (beg_delta != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    os::release_memory(addr, beg_delta);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  if (end_delta != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    char* release_addr = (char*) (s + beg_delta + required_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
    os::release_memory(release_addr, end_delta);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  return (char*) (s + beg_delta);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
char* ReservedSpace::reserve_and_align(const size_t reserve_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
                                       const size_t prefix_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
                                       const size_t prefix_align,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
                                       const size_t suffix_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
                                       const size_t suffix_align)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  assert(reserve_size > prefix_size + suffix_size, "should not be here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  char* raw_addr = os::reserve_memory(reserve_size, NULL, prefix_align);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
  if (raw_addr == NULL) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  char* result = align_reserved_region(raw_addr, reserve_size, prefix_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
                                       prefix_align, suffix_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
                                       suffix_align);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  if (result == NULL && !os::release_memory(raw_addr, reserve_size)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
    fatal("os::release_memory failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  if (result != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    const size_t raw = size_t(raw_addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    const size_t res = size_t(result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
    assert(res >= raw, "alignment decreased start addr");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    assert(res + prefix_size + suffix_size <= raw + reserve_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
           "alignment increased end addr");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
    assert((res & prefix_align - 1) == 0, "bad alignment of prefix");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
    assert((res + prefix_size & suffix_align - 1) == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
           "bad alignment of suffix");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
5898
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   125
// Helper method.
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   126
static bool failed_to_reserve_as_requested(char* base, char* requested_address,
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   127
                                           const size_t size, bool special)
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   128
{
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   129
  if (base == requested_address || requested_address == NULL)
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   130
    return false; // did not fail
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   131
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   132
  if (base != NULL) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   133
    // Different reserve address may be acceptable in other cases
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   134
    // but for compressed oops heap should be at requested address.
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   135
    assert(UseCompressedOops, "currently requested address used only for compressed oops");
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   136
    if (PrintCompressedOopsMode) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   137
      tty->cr();
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   138
      tty->print_cr("Reserved memory at not requested address: " PTR_FORMAT " vs " PTR_FORMAT, base, requested_address);
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   139
    }
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   140
    // OS ignored requested address. Try different address.
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   141
    if (special) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   142
      if (!os::release_memory_special(base, size)) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   143
        fatal("os::release_memory_special failed");
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   144
      }
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   145
    } else {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   146
      if (!os::release_memory(base, size)) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   147
        fatal("os::release_memory failed");
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   148
      }
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   149
    }
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   150
  }
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   151
  return true;
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   152
}
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   153
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
ReservedSpace::ReservedSpace(const size_t prefix_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
                             const size_t prefix_align,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
                             const size_t suffix_size,
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   157
                             const size_t suffix_align,
2254
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   158
                             char* requested_address,
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   159
                             const size_t noaccess_prefix)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  assert(prefix_size != 0, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  assert(prefix_align != 0, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  assert(suffix_size != 0, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  assert(suffix_align != 0, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  assert((prefix_size & prefix_align - 1) == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    "prefix_size not divisible by prefix_align");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  assert((suffix_size & suffix_align - 1) == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
    "suffix_size not divisible by suffix_align");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  assert((suffix_align & prefix_align - 1) == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
    "suffix_align not divisible by prefix_align");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
5898
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   172
  // Assert that if noaccess_prefix is used, it is the same as prefix_align.
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   173
  assert(noaccess_prefix == 0 ||
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   174
         noaccess_prefix == prefix_align, "noaccess prefix wrong");
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   175
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   176
  // Add in noaccess_prefix to prefix_size;
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   177
  const size_t adjusted_prefix_size = prefix_size + noaccess_prefix;
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   178
  const size_t size = adjusted_prefix_size + suffix_size;
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   179
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // On systems where the entire region has to be reserved and committed up
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  // front, the compound alignment normally done by this method is unnecessary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  const bool try_reserve_special = UseLargePages &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
    prefix_align == os::large_page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  if (!os::can_commit_large_page_memory() && try_reserve_special) {
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   185
    initialize(size, prefix_align, true, requested_address, noaccess_prefix,
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   186
               false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  _base = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  _size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  _alignment = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  _special = false;
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   194
  _noaccess_prefix = 0;
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   195
  _executable = false;
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   196
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  // Optimistically try to reserve the exact size needed.
2254
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   198
  char* addr;
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   199
  if (requested_address != 0) {
5898
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   200
    requested_address -= noaccess_prefix; // adjust address
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   201
    assert(requested_address != NULL, "huge noaccess prefix?");
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   202
    addr = os::attempt_reserve_memory_at(size, requested_address);
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   203
    if (failed_to_reserve_as_requested(addr, requested_address, size, false)) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   204
      // OS ignored requested address. Try different address.
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   205
      addr = NULL;
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   206
    }
2254
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   207
  } else {
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   208
    addr = os::reserve_memory(size, NULL, prefix_align);
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   209
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  if (addr == NULL) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  // Check whether the result has the needed alignment (unlikely unless
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  // prefix_align == suffix_align).
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   214
  const size_t ofs = size_t(addr) + adjusted_prefix_size & suffix_align - 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  if (ofs != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    // Wrong alignment.  Release, allocate more space and do manual alignment.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    // On most operating systems, another allocation with a somewhat larger size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    // will return an address "close to" that of the previous allocation.  The
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    // result is often the same address (if the kernel hands out virtual
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    // addresses from low to high), or an address that is offset by the increase
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    // in size.  Exploit that to minimize the amount of extra space requested.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    if (!os::release_memory(addr, size)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
      fatal("os::release_memory failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    const size_t extra = MAX2(ofs, suffix_align - ofs);
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   228
    addr = reserve_and_align(size + extra, adjusted_prefix_size, prefix_align,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
                             suffix_size, suffix_align);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    if (addr == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
      // Try an even larger region.  If this fails, address space is exhausted.
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   232
      addr = reserve_and_align(size + suffix_align, adjusted_prefix_size,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
                               prefix_align, suffix_size, suffix_align);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  _base = addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  _size = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  _alignment = prefix_align;
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   240
  _noaccess_prefix = noaccess_prefix;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
void ReservedSpace::initialize(size_t size, size_t alignment, bool large,
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   244
                               char* requested_address,
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   245
                               const size_t noaccess_prefix,
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   246
                               bool executable) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  const size_t granularity = os::vm_allocation_granularity();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  assert((size & granularity - 1) == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
         "size not aligned to os::vm_allocation_granularity()");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  assert((alignment & granularity - 1) == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
         "alignment not aligned to os::vm_allocation_granularity()");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  assert(alignment == 0 || is_power_of_2((intptr_t)alignment),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
         "not a power of 2");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  _base = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  _size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  _special = false;
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   258
  _executable = executable;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  _alignment = 0;
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   260
  _noaccess_prefix = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  if (size == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  // If OS doesn't support demand paging for large page memory, we need
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  // to use reserve_memory_special() to reserve and pin the entire region.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  bool special = large && !os::can_commit_large_page_memory();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  char* base = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
5898
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   270
  if (requested_address != 0) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   271
    requested_address -= noaccess_prefix; // adjust requested address
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   272
    assert(requested_address != NULL, "huge noaccess prefix?");
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   273
  }
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   274
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  if (special) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   277
    base = os::reserve_memory_special(size, requested_address, executable);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    if (base != NULL) {
5898
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   280
      if (failed_to_reserve_as_requested(base, requested_address, size, true)) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   281
        // OS ignored requested address. Try different address.
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   282
        return;
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   283
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
      // Check alignment constraints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
      if (alignment > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
        assert((uintptr_t) base % alignment == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
               "Large pages returned a non-aligned address");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
      _special = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
      // failed; try to reserve regular memory below
5898
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   292
      if (UseLargePages && (!FLAG_IS_DEFAULT(UseLargePages) ||
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   293
                            !FLAG_IS_DEFAULT(LargePageSizeInBytes))) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   294
        if (PrintCompressedOopsMode) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   295
          tty->cr();
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   296
          tty->print_cr("Reserve regular memory without large pages.");
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   297
        }
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   298
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  if (base == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    // Optimistically assume that the OSes returns an aligned base pointer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    // When reserving a large address range, most OSes seem to align to at
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
    // least 64K.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    // If the memory was requested at a particular address, use
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    // os::attempt_reserve_memory_at() to avoid over mapping something
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
    // important.  If available space is not detected, return NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
    if (requested_address != 0) {
5898
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   312
      base = os::attempt_reserve_memory_at(size, requested_address);
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   313
      if (failed_to_reserve_as_requested(base, requested_address, size, false)) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   314
        // OS ignored requested address. Try different address.
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   315
        base = NULL;
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   316
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
      base = os::reserve_memory(size, NULL, alignment);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
    if (base == NULL) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
    // Check alignment constraints
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    if (alignment > 0 && ((size_t)base & alignment - 1) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
      // Base not aligned, retry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
      if (!os::release_memory(base, size)) fatal("os::release_memory failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
      // Reserve size large enough to do manual alignment and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
      // increase size to a multiple of the desired alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
      size = align_size_up(size, alignment);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
      size_t extra_size = size + alignment;
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   331
      do {
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   332
        char* extra_base = os::reserve_memory(extra_size, NULL, alignment);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   333
        if (extra_base == NULL) return;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   334
        // Do manual alignement
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   335
        base = (char*) align_size_up((uintptr_t) extra_base, alignment);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   336
        assert(base >= extra_base, "just checking");
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   337
        // Re-reserve the region at the aligned base address.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   338
        os::release_memory(extra_base, extra_size);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   339
        base = os::reserve_memory(size, base);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 1
diff changeset
   340
      } while (base == NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  // Done
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  _base = base;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  _size = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  _alignment = MAX2(alignment, (size_t) os::vm_page_size());
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   347
  _noaccess_prefix = noaccess_prefix;
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   348
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   349
  // Assert that if noaccess_prefix is used, it is the same as alignment.
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   350
  assert(noaccess_prefix == 0 ||
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   351
         noaccess_prefix == _alignment, "noaccess prefix wrong");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  assert(markOopDesc::encode_pointer_as_mark(_base)->decode_pointer() == _base,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
         "area must be distinguisable from marks for mark-sweep");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  assert(markOopDesc::encode_pointer_as_mark(&_base[size])->decode_pointer() == &_base[size],
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
         "area must be distinguisable from marks for mark-sweep");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
ReservedSpace::ReservedSpace(char* base, size_t size, size_t alignment,
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   361
                             bool special, bool executable) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  assert((size % os::vm_allocation_granularity()) == 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
         "size not allocation aligned");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  _base = base;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  _size = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  _alignment = alignment;
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   367
  _noaccess_prefix = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  _special = special;
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   369
  _executable = executable;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
ReservedSpace ReservedSpace::first_part(size_t partition_size, size_t alignment,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
                                        bool split, bool realloc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  assert(partition_size <= size(), "partition failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  if (split) {
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   377
    os::split_reserved_memory(base(), size(), partition_size, realloc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  }
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   379
  ReservedSpace result(base(), partition_size, alignment, special(),
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   380
                       executable());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
ReservedSpace
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
ReservedSpace::last_part(size_t partition_size, size_t alignment) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  assert(partition_size <= size(), "partition failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  ReservedSpace result(base() + partition_size, size() - partition_size,
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   389
                       alignment, special(), executable());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
size_t ReservedSpace::page_align_size_up(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  return align_size_up(size, os::vm_page_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
size_t ReservedSpace::page_align_size_down(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  return align_size_down(size, os::vm_page_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
size_t ReservedSpace::allocation_align_size_up(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
  return align_size_up(size, os::vm_allocation_granularity());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
size_t ReservedSpace::allocation_align_size_down(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  return align_size_down(size, os::vm_allocation_granularity());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
void ReservedSpace::release() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  if (is_reserved()) {
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   416
    char *real_base = _base - _noaccess_prefix;
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   417
    const size_t real_size = _size + _noaccess_prefix;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
    if (special()) {
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   419
      os::release_memory_special(real_base, real_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
    } else{
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   421
      os::release_memory(real_base, real_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
    _base = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
    _size = 0;
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   425
    _noaccess_prefix = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
    _special = false;
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   427
    _executable = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   431
void ReservedSpace::protect_noaccess_prefix(const size_t size) {
5898
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   432
  assert( (_noaccess_prefix != 0) == (UseCompressedOops && _base != NULL &&
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   433
                                      (size_t(_base + _size) > OopEncodingHeapMax) &&
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   434
                                      Universe::narrow_oop_use_implicit_null_checks()),
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   435
         "noaccess_prefix should be used only with non zero based compressed oops");
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   436
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   437
  // If there is no noaccess prefix, return.
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   438
  if (_noaccess_prefix == 0) return;
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   439
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   440
  assert(_noaccess_prefix >= (size_t)os::vm_page_size(),
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   441
         "must be at least page size big");
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   442
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   443
  // Protect memory at the base of the allocated region.
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   444
  // If special, the page was committed (only matters on windows)
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   445
  if (!os::protect_memory(_base, _noaccess_prefix, os::MEM_PROT_NONE,
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   446
                          _special)) {
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   447
    fatal("cannot protect protection page");
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   448
  }
5898
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   449
  if (PrintCompressedOopsMode) {
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   450
    tty->cr();
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   451
    tty->print_cr("Protected page at the reserved heap base: " PTR_FORMAT " / " INTX_FORMAT " bytes", _base, _noaccess_prefix);
7f882d601e07 6947341: JVM Crash running Oracle ATG CRMDemo
kvn
parents: 5547
diff changeset
   452
  }
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   453
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   454
  _base += _noaccess_prefix;
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   455
  _size -= _noaccess_prefix;
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   456
  assert((size == _size) && ((uintptr_t)_base % _alignment == 0),
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   457
         "must be exactly of required size and alignment");
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   458
}
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   459
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   460
ReservedHeapSpace::ReservedHeapSpace(size_t size, size_t alignment,
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   461
                                     bool large, char* requested_address) :
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   462
  ReservedSpace(size, alignment, large,
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   463
                requested_address,
2254
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   464
                (UseCompressedOops && (Universe::narrow_oop_base() != NULL) &&
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   465
                 Universe::narrow_oop_use_implicit_null_checks()) ?
1129
ec4dfac10759 6741004: UseLargePages + UseCompressedOops breaks implicit null checking guard page
coleenp
parents: 823
diff changeset
   466
                  lcm(os::vm_page_size(), alignment) : 0) {
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   467
  // Only reserved space for the java heap should have a noaccess_prefix
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   468
  // if using compressed oops.
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   469
  protect_noaccess_prefix(size);
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   470
}
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   471
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   472
ReservedHeapSpace::ReservedHeapSpace(const size_t prefix_size,
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   473
                                     const size_t prefix_align,
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   474
                                     const size_t suffix_size,
2254
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   475
                                     const size_t suffix_align,
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   476
                                     char* requested_address) :
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   477
  ReservedSpace(prefix_size, prefix_align, suffix_size, suffix_align,
2254
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   478
                requested_address,
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   479
                (UseCompressedOops && (Universe::narrow_oop_base() != NULL) &&
f13dda645a4b 6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents: 1412
diff changeset
   480
                 Universe::narrow_oop_use_implicit_null_checks()) ?
1129
ec4dfac10759 6741004: UseLargePages + UseCompressedOops breaks implicit null checking guard page
coleenp
parents: 823
diff changeset
   481
                  lcm(os::vm_page_size(), prefix_align) : 0) {
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   482
  protect_noaccess_prefix(prefix_size+suffix_size);
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   483
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   485
// Reserve space for code segment.  Same as Java heap only we mark this as
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   486
// executable.
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   487
ReservedCodeSpace::ReservedCodeSpace(size_t r_size,
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   488
                                     size_t rs_align,
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   489
                                     bool large) :
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   490
  ReservedSpace(r_size, rs_align, large, /*executable*/ true) {
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   491
}
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   492
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
// VirtualSpace
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
VirtualSpace::VirtualSpace() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  _low_boundary           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  _high_boundary          = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  _low                    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  _high                   = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  _lower_high             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  _middle_high            = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  _upper_high             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  _lower_high_boundary    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  _middle_high_boundary   = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  _upper_high_boundary    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  _lower_alignment        = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  _middle_alignment       = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  _upper_alignment        = 0;
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   509
  _special                = false;
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   510
  _executable             = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
bool VirtualSpace::initialize(ReservedSpace rs, size_t committed_size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  if(!rs.is_reserved()) return false;  // allocation failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  assert(_low_boundary == NULL, "VirtualSpace already initialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  _low_boundary  = rs.base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  _high_boundary = low_boundary() + rs.size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  _low = low_boundary();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  _high = low();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  _special = rs.special();
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   524
  _executable = rs.executable();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  // When a VirtualSpace begins life at a large size, make all future expansion
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  // and shrinking occur aligned to a granularity of large pages.  This avoids
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  // fragmentation of physical addresses that inhibits the use of large pages
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // by the OS virtual memory system.  Empirically,  we see that with a 4MB
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  // page size, the only spaces that get handled this way are codecache and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  // the heap itself, both of which provide a substantial performance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  // boost in many benchmarks when covered by large pages.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  // No attempt is made to force large page alignment at the very top and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  // bottom of the space if they are not aligned so already.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  _lower_alignment  = os::vm_page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  _middle_alignment = os::page_size_for_region(rs.size(), rs.size(), 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  _upper_alignment  = os::vm_page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  // End of each region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  _lower_high_boundary = (char*) round_to((intptr_t) low_boundary(), middle_alignment());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  _middle_high_boundary = (char*) round_down((intptr_t) high_boundary(), middle_alignment());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  _upper_high_boundary = high_boundary();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  // High address of each region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
  _lower_high = low_boundary();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  _middle_high = lower_high_boundary();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  _upper_high = middle_high_boundary();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  // commit to initial size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  if (committed_size > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
    if (!expand_by(committed_size)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
VirtualSpace::~VirtualSpace() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  release();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
void VirtualSpace::release() {
823
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   566
  // This does not release memory it never reserved.
9a5271881bc0 6716785: implicit null checks not triggering with CompressedOops
coleenp
parents: 1
diff changeset
   567
  // Caller must release via rs.release();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  _low_boundary           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  _high_boundary          = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  _low                    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  _high                   = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  _lower_high             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  _middle_high            = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  _upper_high             = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  _lower_high_boundary    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  _middle_high_boundary   = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  _upper_high_boundary    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  _lower_alignment        = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  _middle_alignment       = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  _upper_alignment        = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  _special                = false;
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   582
  _executable             = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
size_t VirtualSpace::committed_size() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  return pointer_delta(high(), low(), sizeof(char));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
size_t VirtualSpace::reserved_size() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  return pointer_delta(high_boundary(), low_boundary(), sizeof(char));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
size_t VirtualSpace::uncommitted_size()  const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  return reserved_size() - committed_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
bool VirtualSpace::contains(const void* p) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  return low() <= (const char*) p && (const char*) p < high();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
   First we need to determine if a particular virtual space is using large
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
   pages.  This is done at the initialize function and only virtual spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
   that are larger than LargePageSizeInBytes use large pages.  Once we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
   have determined this, all expand_by and shrink_by calls must grow and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
   shrink by large page size chunks.  If a particular request
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
   is within the current large page, the call to commit and uncommit memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
   can be ignored.  In the case that the low and high boundaries of this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
   space is not large page aligned, the pages leading to the first large
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
   page address and the pages after the last large page address must be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
   allocated with default pages.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
bool VirtualSpace::expand_by(size_t bytes, bool pre_touch) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  if (uncommitted_size() < bytes) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  if (special()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
    // don't commit memory if the entire space is pinned in memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
    _high += bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  char* previous_high = high();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  char* unaligned_new_high = high() + bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  assert(unaligned_new_high <= high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
         "cannot expand by more than upper boundary");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  // Calculate where the new high for each of the regions should be.  If
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  // the low_boundary() and high_boundary() are LargePageSizeInBytes aligned
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  // then the unaligned lower and upper new highs would be the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
  // lower_high() and upper_high() respectively.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
  char* unaligned_lower_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
    MIN2(unaligned_new_high, lower_high_boundary());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  char* unaligned_middle_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
    MIN2(unaligned_new_high, middle_high_boundary());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
  char* unaligned_upper_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
    MIN2(unaligned_new_high, upper_high_boundary());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  // Align the new highs based on the regions alignment.  lower and upper
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
  // alignment will always be default page size.  middle alignment will be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  // LargePageSizeInBytes if the actual size of the virtual space is in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  // fact larger than LargePageSizeInBytes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  char* aligned_lower_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
    (char*) round_to((intptr_t) unaligned_lower_new_high, lower_alignment());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  char* aligned_middle_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
    (char*) round_to((intptr_t) unaligned_middle_new_high, middle_alignment());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  char* aligned_upper_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
    (char*) round_to((intptr_t) unaligned_upper_new_high, upper_alignment());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  // Determine which regions need to grow in this expand_by call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  // If you are growing in the lower region, high() must be in that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  // region so calcuate the size based on high().  For the middle and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  // upper regions, determine the starting point of growth based on the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  // location of high().  By getting the MAX of the region's low address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  // (or the prevoius region's high address) and high(), we can tell if it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  // is an intra or inter region growth.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  size_t lower_needs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  if (aligned_lower_new_high > lower_high()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
    lower_needs =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
      pointer_delta(aligned_lower_new_high, lower_high(), sizeof(char));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
  size_t middle_needs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  if (aligned_middle_new_high > middle_high()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
    middle_needs =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
      pointer_delta(aligned_middle_new_high, middle_high(), sizeof(char));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
  size_t upper_needs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  if (aligned_upper_new_high > upper_high()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    upper_needs =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
      pointer_delta(aligned_upper_new_high, upper_high(), sizeof(char));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  // Check contiguity.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  assert(low_boundary() <= lower_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
         lower_high() <= lower_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
         "high address must be contained within the region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
  assert(lower_high_boundary() <= middle_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
         middle_high() <= middle_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
         "high address must be contained within the region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  assert(middle_high_boundary() <= upper_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
         upper_high() <= upper_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
         "high address must be contained within the region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  // Commit regions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  if (lower_needs > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
    assert(low_boundary() <= lower_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
           lower_high() + lower_needs <= lower_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
           "must not expand beyond region");
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   692
    if (!os::commit_memory(lower_high(), lower_needs, _executable)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
      debug_only(warning("os::commit_memory failed"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
      _lower_high += lower_needs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
  if (middle_needs > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
    assert(lower_high_boundary() <= middle_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
           middle_high() + middle_needs <= middle_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
           "must not expand beyond region");
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   703
    if (!os::commit_memory(middle_high(), middle_needs, middle_alignment(),
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   704
                           _executable)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
      debug_only(warning("os::commit_memory failed"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
    _middle_high += middle_needs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  if (upper_needs > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    assert(middle_high_boundary() <= upper_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
           upper_high() + upper_needs <= upper_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
           "must not expand beyond region");
2268
bea8be80ec88 6541756: Reduce executable C-heap
coleenp
parents: 2254
diff changeset
   714
    if (!os::commit_memory(upper_high(), upper_needs, _executable)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
      debug_only(warning("os::commit_memory failed"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
      _upper_high += upper_needs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  if (pre_touch || AlwaysPreTouch) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
    int vm_ps = os::vm_page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
    for (char* curr = previous_high;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
         curr < unaligned_new_high;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
         curr += vm_ps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
      // Note the use of a write here; originally we tried just a read, but
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
      // since the value read was unused, the optimizer removed the read.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
      // If we ever have a concurrent touchahead thread, we'll want to use
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
      // a read, to avoid the potential of overwriting data (if a mutator
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
      // thread beats the touchahead thread to a page).  There are various
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
      // ways of making sure this read is not optimized away: for example,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
      // generating the code for a read procedure at runtime.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
      *curr = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  _high += bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
// A page is uncommitted if the contents of the entire page is deemed unusable.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
// Continue to decrement the high() pointer until it reaches a page boundary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
// in which case that particular page can now be uncommitted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
void VirtualSpace::shrink_by(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  if (committed_size() < size)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
    fatal("Cannot shrink virtual space to negative size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  if (special()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
    // don't uncommit if the entire space is pinned in memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
    _high -= size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  char* unaligned_new_high = high() - size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  assert(unaligned_new_high >= low_boundary(), "cannot shrink past lower boundary");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
  // Calculate new unaligned address
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  char* unaligned_upper_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
    MAX2(unaligned_new_high, middle_high_boundary());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  char* unaligned_middle_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    MAX2(unaligned_new_high, lower_high_boundary());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
  char* unaligned_lower_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
    MAX2(unaligned_new_high, low_boundary());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  // Align address to region's alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  char* aligned_upper_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
    (char*) round_to((intptr_t) unaligned_upper_new_high, upper_alignment());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  char* aligned_middle_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
    (char*) round_to((intptr_t) unaligned_middle_new_high, middle_alignment());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  char* aligned_lower_new_high =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
    (char*) round_to((intptr_t) unaligned_lower_new_high, lower_alignment());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  // Determine which regions need to shrink
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  size_t upper_needs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  if (aligned_upper_new_high < upper_high()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
    upper_needs =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
      pointer_delta(upper_high(), aligned_upper_new_high, sizeof(char));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  size_t middle_needs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  if (aligned_middle_new_high < middle_high()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
    middle_needs =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
      pointer_delta(middle_high(), aligned_middle_new_high, sizeof(char));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  size_t lower_needs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  if (aligned_lower_new_high < lower_high()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
    lower_needs =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
      pointer_delta(lower_high(), aligned_lower_new_high, sizeof(char));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  // Check contiguity.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  assert(middle_high_boundary() <= upper_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
         upper_high() <= upper_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
         "high address must be contained within the region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  assert(lower_high_boundary() <= middle_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
         middle_high() <= middle_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
         "high address must be contained within the region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  assert(low_boundary() <= lower_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
         lower_high() <= lower_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
         "high address must be contained within the region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  // Uncommit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  if (upper_needs > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    assert(middle_high_boundary() <= aligned_upper_new_high &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
           aligned_upper_new_high + upper_needs <= upper_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
           "must not shrink beyond region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
    if (!os::uncommit_memory(aligned_upper_new_high, upper_needs)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
      debug_only(warning("os::uncommit_memory failed"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
      _upper_high -= upper_needs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
  if (middle_needs > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
    assert(lower_high_boundary() <= aligned_middle_new_high &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
           aligned_middle_new_high + middle_needs <= middle_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
           "must not shrink beyond region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
    if (!os::uncommit_memory(aligned_middle_new_high, middle_needs)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
      debug_only(warning("os::uncommit_memory failed"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
      _middle_high -= middle_needs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  if (lower_needs > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    assert(low_boundary() <= aligned_lower_new_high &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
           aligned_lower_new_high + lower_needs <= lower_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
           "must not shrink beyond region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
    if (!os::uncommit_memory(aligned_lower_new_high, lower_needs)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
      debug_only(warning("os::uncommit_memory failed"));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
      _lower_high -= lower_needs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  _high -= size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
void VirtualSpace::check_for_contiguity() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  // Check contiguity.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  assert(low_boundary() <= lower_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
         lower_high() <= lower_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
         "high address must be contained within the region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  assert(lower_high_boundary() <= middle_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
         middle_high() <= middle_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
         "high address must be contained within the region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  assert(middle_high_boundary() <= upper_high() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
         upper_high() <= upper_high_boundary(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
         "high address must be contained within the region");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  assert(low() >= low_boundary(), "low");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  assert(low_boundary() <= lower_high_boundary(), "lower high boundary");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  assert(upper_high_boundary() <= high_boundary(), "upper high boundary");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  assert(high() <= upper_high(), "upper high");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
void VirtualSpace::print() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  tty->print   ("Virtual space:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  if (special()) tty->print(" (pinned in memory)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  tty->print_cr(" - committed: %ld", committed_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  tty->print_cr(" - reserved:  %ld", reserved_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  tty->print_cr(" - [low, high]:     [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",  low(), high());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  tty->print_cr(" - [low_b, high_b]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]",  low_boundary(), high_boundary());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
#endif