Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/virtualspace.hpp @ 8804:91bf0bdae37b
8008217: CDS: Class data sharing limits the malloc heap on Solaris
Summary: In 64bit VM move CDS archive address to 32G on all platforms using new flag SharedBaseAddress. In 32bit VM set CDS archive address to 3Gb on Linux and let other OSs pick the address.
Reviewed-by: kvn, dcubed, zgu, hseigel
| author | coleenp |
|---|---|
| date | Wed, 20 Mar 2013 08:04:54 -0400 |
| parents | da91efe96a93 |
| children | b294421fa3c5 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
844
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
844
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
844
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_RUNTIME_VIRTUALSPACE_HPP |
| 26 #define SHARE_VM_RUNTIME_VIRTUALSPACE_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
| 29 | |
| 0 | 30 // ReservedSpace is a data structure for reserving a contiguous address range. |
| 31 | |
| 32 class ReservedSpace VALUE_OBJ_CLASS_SPEC { | |
| 33 friend class VMStructs; | |
| 34 private: | |
| 35 char* _base; | |
| 36 size_t _size; | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
37 size_t _noaccess_prefix; |
| 0 | 38 size_t _alignment; |
| 39 bool _special; | |
| 656 | 40 bool _executable; |
| 0 | 41 |
| 42 // ReservedSpace | |
| 656 | 43 ReservedSpace(char* base, size_t size, size_t alignment, bool special, |
| 44 bool executable); | |
| 0 | 45 void initialize(size_t size, size_t alignment, bool large, |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
46 char* requested_address, |
| 656 | 47 const size_t noaccess_prefix, |
| 48 bool executable); | |
| 0 | 49 |
| 50 // Release parts of an already-reserved memory region [addr, addr + len) to | |
| 51 // get a new region that has "compound alignment." Return the start of the | |
| 52 // resulting region, or NULL on failure. | |
| 53 // | |
| 54 // The region is logically divided into a prefix and a suffix. The prefix | |
| 55 // starts at the result address, which is aligned to prefix_align. The suffix | |
| 56 // starts at result address + prefix_size, which is aligned to suffix_align. | |
| 57 // The total size of the result region is size prefix_size + suffix_size. | |
| 58 char* align_reserved_region(char* addr, const size_t len, | |
| 59 const size_t prefix_size, | |
| 60 const size_t prefix_align, | |
| 61 const size_t suffix_size, | |
| 62 const size_t suffix_align); | |
| 63 | |
| 64 // Reserve memory, call align_reserved_region() to alignment it and return the | |
| 65 // result. | |
| 66 char* reserve_and_align(const size_t reserve_size, | |
| 67 const size_t prefix_size, | |
| 68 const size_t prefix_align, | |
| 69 const size_t suffix_size, | |
| 70 const size_t suffix_align); | |
| 71 | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
72 protected: |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
73 // Create protection page at the beginning of the space. |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
74 void protect_noaccess_prefix(const size_t size); |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
75 |
| 0 | 76 public: |
| 77 // Constructor | |
| 78 ReservedSpace(size_t size); | |
| 79 ReservedSpace(size_t size, size_t alignment, bool large, | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
80 char* requested_address = NULL, |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
81 const size_t noaccess_prefix = 0); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1972
diff
changeset
|
82 ReservedSpace(const size_t suffix_size, const size_t suffix_align, |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
337
diff
changeset
|
83 char* requested_address, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
337
diff
changeset
|
84 const size_t noaccess_prefix = 0); |
| 656 | 85 ReservedSpace(size_t size, size_t alignment, bool large, bool executable); |
| 0 | 86 |
| 87 // Accessors | |
| 656 | 88 char* base() const { return _base; } |
| 89 size_t size() const { return _size; } | |
| 90 size_t alignment() const { return _alignment; } | |
| 91 bool special() const { return _special; } | |
| 92 bool executable() const { return _executable; } | |
| 93 size_t noaccess_prefix() const { return _noaccess_prefix; } | |
| 94 bool is_reserved() const { return _base != NULL; } | |
| 0 | 95 void release(); |
| 96 | |
| 97 // Splitting | |
| 98 ReservedSpace first_part(size_t partition_size, size_t alignment, | |
| 99 bool split = false, bool realloc = true); | |
| 100 ReservedSpace last_part (size_t partition_size, size_t alignment); | |
| 101 | |
| 102 // These simply call the above using the default alignment. | |
| 103 inline ReservedSpace first_part(size_t partition_size, | |
| 104 bool split = false, bool realloc = true); | |
| 105 inline ReservedSpace last_part (size_t partition_size); | |
| 106 | |
| 107 // Alignment | |
| 108 static size_t page_align_size_up(size_t size); | |
| 109 static size_t page_align_size_down(size_t size); | |
| 110 static size_t allocation_align_size_up(size_t size); | |
| 111 static size_t allocation_align_size_down(size_t size); | |
| 112 }; | |
| 113 | |
| 114 ReservedSpace | |
| 115 ReservedSpace::first_part(size_t partition_size, bool split, bool realloc) | |
| 116 { | |
| 117 return first_part(partition_size, alignment(), split, realloc); | |
| 118 } | |
| 119 | |
| 120 ReservedSpace ReservedSpace::last_part(size_t partition_size) | |
| 121 { | |
| 122 return last_part(partition_size, alignment()); | |
| 123 } | |
| 124 | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
125 // Class encapsulating behavior specific of memory space reserved for Java heap |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
126 class ReservedHeapSpace : public ReservedSpace { |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
127 public: |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
128 // Constructor |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
129 ReservedHeapSpace(size_t size, size_t forced_base_alignment, |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
130 bool large, char* requested_address); |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
131 ReservedHeapSpace(const size_t prefix_size, const size_t prefix_align, |
|
642
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
337
diff
changeset
|
132 char* requested_address); |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
133 }; |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
134 |
| 656 | 135 // Class encapsulating behavior specific memory space for Code |
| 136 class ReservedCodeSpace : public ReservedSpace { | |
| 137 public: | |
| 138 // Constructor | |
| 139 ReservedCodeSpace(size_t r_size, size_t rs_align, bool large); | |
| 140 }; | |
| 141 | |
| 0 | 142 // VirtualSpace is data structure for committing a previously reserved address range in smaller chunks. |
| 143 | |
| 144 class VirtualSpace VALUE_OBJ_CLASS_SPEC { | |
| 145 friend class VMStructs; | |
| 146 private: | |
| 147 // Reserved area | |
| 148 char* _low_boundary; | |
| 149 char* _high_boundary; | |
| 150 | |
| 151 // Committed area | |
| 152 char* _low; | |
| 153 char* _high; | |
| 154 | |
| 155 // The entire space has been committed and pinned in memory, no | |
| 156 // os::commit_memory() or os::uncommit_memory(). | |
| 157 bool _special; | |
| 158 | |
| 656 | 159 // Need to know if commit should be executable. |
| 160 bool _executable; | |
| 161 | |
| 0 | 162 // MPSS Support |
| 163 // Each virtualspace region has a lower, middle, and upper region. | |
| 164 // Each region has an end boundary and a high pointer which is the | |
| 165 // high water mark for the last allocated byte. | |
| 166 // The lower and upper unaligned to LargePageSizeInBytes uses default page. | |
| 167 // size. The middle region uses large page size. | |
| 168 char* _lower_high; | |
| 169 char* _middle_high; | |
| 170 char* _upper_high; | |
| 171 | |
| 172 char* _lower_high_boundary; | |
| 173 char* _middle_high_boundary; | |
| 174 char* _upper_high_boundary; | |
| 175 | |
| 176 size_t _lower_alignment; | |
| 177 size_t _middle_alignment; | |
| 178 size_t _upper_alignment; | |
| 179 | |
| 180 // MPSS Accessors | |
| 181 char* lower_high() const { return _lower_high; } | |
| 182 char* middle_high() const { return _middle_high; } | |
| 183 char* upper_high() const { return _upper_high; } | |
| 184 | |
| 185 char* lower_high_boundary() const { return _lower_high_boundary; } | |
| 186 char* middle_high_boundary() const { return _middle_high_boundary; } | |
| 187 char* upper_high_boundary() const { return _upper_high_boundary; } | |
| 188 | |
| 189 size_t lower_alignment() const { return _lower_alignment; } | |
| 190 size_t middle_alignment() const { return _middle_alignment; } | |
| 191 size_t upper_alignment() const { return _upper_alignment; } | |
| 192 | |
| 193 public: | |
| 194 // Committed area | |
| 195 char* low() const { return _low; } | |
| 196 char* high() const { return _high; } | |
| 197 | |
| 198 // Reserved area | |
| 199 char* low_boundary() const { return _low_boundary; } | |
| 200 char* high_boundary() const { return _high_boundary; } | |
| 201 | |
| 202 bool special() const { return _special; } | |
| 203 | |
| 204 public: | |
| 205 // Initialization | |
| 206 VirtualSpace(); | |
| 207 bool initialize(ReservedSpace rs, size_t committed_byte_size); | |
| 208 | |
| 209 // Destruction | |
| 210 ~VirtualSpace(); | |
| 211 | |
| 212 // Testers (all sizes are byte sizes) | |
| 213 size_t committed_size() const; | |
| 214 size_t reserved_size() const; | |
| 215 size_t uncommitted_size() const; | |
| 216 bool contains(const void* p) const; | |
| 217 | |
| 218 // Operations | |
| 219 // returns true on success, false otherwise | |
| 220 bool expand_by(size_t bytes, bool pre_touch = false); | |
| 221 void shrink_by(size_t bytes); | |
| 222 void release(); | |
| 223 | |
| 224 void check_for_contiguity() PRODUCT_RETURN; | |
| 225 | |
| 226 // Debugging | |
| 227 void print() PRODUCT_RETURN; | |
| 228 }; | |
| 1972 | 229 |
| 230 #endif // SHARE_VM_RUNTIME_VIRTUALSPACE_HPP |