Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/virtualspace.hpp @ 1091:6aa7255741f3
6906727: UseCompressedOops: some card-marking fixes related to object arrays
Summary: Introduced a new write_ref_array(HeapWords* start, size_t count) method that does the requisite MemRegion range calculation so (some of the) clients of the erstwhile write_ref_array(MemRegion mr) do not need to worry. This removed all external uses of array_size(), which was also simplified and made private. Asserts were added to catch other possible issues. Further, less essential, fixes stemming from this investigation are deferred to CR 6904516 (to follow shortly in hs17).
Reviewed-by: kvn, coleenp, jmasa
| author | ysr |
|---|---|
| date | Thu, 03 Dec 2009 15:01:57 -0800 |
| parents | bd02caa94611 |
| children | c18cbe5936b8 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 844 | 2 * Copyright 1997-2009 Sun Microsystems, Inc. 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 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 // ReservedSpace is a data structure for reserving a contiguous address range. | |
| 26 | |
| 27 class ReservedSpace VALUE_OBJ_CLASS_SPEC { | |
| 28 friend class VMStructs; | |
| 29 private: | |
| 30 char* _base; | |
| 31 size_t _size; | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
32 size_t _noaccess_prefix; |
| 0 | 33 size_t _alignment; |
| 34 bool _special; | |
| 656 | 35 bool _executable; |
| 0 | 36 |
| 37 // ReservedSpace | |
| 656 | 38 ReservedSpace(char* base, size_t size, size_t alignment, bool special, |
| 39 bool executable); | |
| 0 | 40 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
|
41 char* requested_address, |
| 656 | 42 const size_t noaccess_prefix, |
| 43 bool executable); | |
| 0 | 44 |
| 45 // Release parts of an already-reserved memory region [addr, addr + len) to | |
| 46 // get a new region that has "compound alignment." Return the start of the | |
| 47 // resulting region, or NULL on failure. | |
| 48 // | |
| 49 // The region is logically divided into a prefix and a suffix. The prefix | |
| 50 // starts at the result address, which is aligned to prefix_align. The suffix | |
| 51 // starts at result address + prefix_size, which is aligned to suffix_align. | |
| 52 // The total size of the result region is size prefix_size + suffix_size. | |
| 53 char* align_reserved_region(char* addr, const size_t len, | |
| 54 const size_t prefix_size, | |
| 55 const size_t prefix_align, | |
| 56 const size_t suffix_size, | |
| 57 const size_t suffix_align); | |
| 58 | |
| 59 // Reserve memory, call align_reserved_region() to alignment it and return the | |
| 60 // result. | |
| 61 char* reserve_and_align(const size_t reserve_size, | |
| 62 const size_t prefix_size, | |
| 63 const size_t prefix_align, | |
| 64 const size_t suffix_size, | |
| 65 const size_t suffix_align); | |
| 66 | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
67 protected: |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
68 // Create protection page at the beginning of the space. |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
69 void protect_noaccess_prefix(const size_t size); |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
70 |
| 0 | 71 public: |
| 72 // Constructor | |
| 73 ReservedSpace(size_t size); | |
| 74 ReservedSpace(size_t size, size_t alignment, bool large, | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
75 char* requested_address = NULL, |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
76 const size_t noaccess_prefix = 0); |
| 0 | 77 ReservedSpace(const size_t prefix_size, const size_t prefix_align, |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
78 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
|
79 char* requested_address, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
337
diff
changeset
|
80 const size_t noaccess_prefix = 0); |
| 656 | 81 ReservedSpace(size_t size, size_t alignment, bool large, bool executable); |
| 0 | 82 |
| 83 // Accessors | |
| 656 | 84 char* base() const { return _base; } |
| 85 size_t size() const { return _size; } | |
| 86 size_t alignment() const { return _alignment; } | |
| 87 bool special() const { return _special; } | |
| 88 bool executable() const { return _executable; } | |
| 89 size_t noaccess_prefix() const { return _noaccess_prefix; } | |
| 90 bool is_reserved() const { return _base != NULL; } | |
| 0 | 91 void release(); |
| 92 | |
| 93 // Splitting | |
| 94 ReservedSpace first_part(size_t partition_size, size_t alignment, | |
| 95 bool split = false, bool realloc = true); | |
| 96 ReservedSpace last_part (size_t partition_size, size_t alignment); | |
| 97 | |
| 98 // These simply call the above using the default alignment. | |
| 99 inline ReservedSpace first_part(size_t partition_size, | |
| 100 bool split = false, bool realloc = true); | |
| 101 inline ReservedSpace last_part (size_t partition_size); | |
| 102 | |
| 103 // Alignment | |
| 104 static size_t page_align_size_up(size_t size); | |
| 105 static size_t page_align_size_down(size_t size); | |
| 106 static size_t allocation_align_size_up(size_t size); | |
| 107 static size_t allocation_align_size_down(size_t size); | |
| 108 }; | |
| 109 | |
| 110 ReservedSpace | |
| 111 ReservedSpace::first_part(size_t partition_size, bool split, bool realloc) | |
| 112 { | |
| 113 return first_part(partition_size, alignment(), split, realloc); | |
| 114 } | |
| 115 | |
| 116 ReservedSpace ReservedSpace::last_part(size_t partition_size) | |
| 117 { | |
| 118 return last_part(partition_size, alignment()); | |
| 119 } | |
| 120 | |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
121 // 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
|
122 class ReservedHeapSpace : public ReservedSpace { |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
123 public: |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
124 // Constructor |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
125 ReservedHeapSpace(size_t size, size_t forced_base_alignment, |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
126 bool large, char* requested_address); |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
127 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
|
128 const size_t suffix_size, const size_t suffix_align, |
|
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
337
diff
changeset
|
129 char* requested_address); |
|
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
130 }; |
|
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
131 |
| 656 | 132 // Class encapsulating behavior specific memory space for Code |
| 133 class ReservedCodeSpace : public ReservedSpace { | |
| 134 public: | |
| 135 // Constructor | |
| 136 ReservedCodeSpace(size_t r_size, size_t rs_align, bool large); | |
| 137 }; | |
| 138 | |
| 0 | 139 // VirtualSpace is data structure for committing a previously reserved address range in smaller chunks. |
| 140 | |
| 141 class VirtualSpace VALUE_OBJ_CLASS_SPEC { | |
| 142 friend class VMStructs; | |
| 143 private: | |
| 144 // Reserved area | |
| 145 char* _low_boundary; | |
| 146 char* _high_boundary; | |
| 147 | |
| 148 // Committed area | |
| 149 char* _low; | |
| 150 char* _high; | |
| 151 | |
| 152 // The entire space has been committed and pinned in memory, no | |
| 153 // os::commit_memory() or os::uncommit_memory(). | |
| 154 bool _special; | |
| 155 | |
| 656 | 156 // Need to know if commit should be executable. |
| 157 bool _executable; | |
| 158 | |
| 0 | 159 // MPSS Support |
| 160 // Each virtualspace region has a lower, middle, and upper region. | |
| 161 // Each region has an end boundary and a high pointer which is the | |
| 162 // high water mark for the last allocated byte. | |
| 163 // The lower and upper unaligned to LargePageSizeInBytes uses default page. | |
| 164 // size. The middle region uses large page size. | |
| 165 char* _lower_high; | |
| 166 char* _middle_high; | |
| 167 char* _upper_high; | |
| 168 | |
| 169 char* _lower_high_boundary; | |
| 170 char* _middle_high_boundary; | |
| 171 char* _upper_high_boundary; | |
| 172 | |
| 173 size_t _lower_alignment; | |
| 174 size_t _middle_alignment; | |
| 175 size_t _upper_alignment; | |
| 176 | |
| 177 // MPSS Accessors | |
| 178 char* lower_high() const { return _lower_high; } | |
| 179 char* middle_high() const { return _middle_high; } | |
| 180 char* upper_high() const { return _upper_high; } | |
| 181 | |
| 182 char* lower_high_boundary() const { return _lower_high_boundary; } | |
| 183 char* middle_high_boundary() const { return _middle_high_boundary; } | |
| 184 char* upper_high_boundary() const { return _upper_high_boundary; } | |
| 185 | |
| 186 size_t lower_alignment() const { return _lower_alignment; } | |
| 187 size_t middle_alignment() const { return _middle_alignment; } | |
| 188 size_t upper_alignment() const { return _upper_alignment; } | |
| 189 | |
| 190 public: | |
| 191 // Committed area | |
| 192 char* low() const { return _low; } | |
| 193 char* high() const { return _high; } | |
| 194 | |
| 195 // Reserved area | |
| 196 char* low_boundary() const { return _low_boundary; } | |
| 197 char* high_boundary() const { return _high_boundary; } | |
| 198 | |
| 199 bool special() const { return _special; } | |
| 200 | |
| 201 public: | |
| 202 // Initialization | |
| 203 VirtualSpace(); | |
| 204 bool initialize(ReservedSpace rs, size_t committed_byte_size); | |
| 205 | |
| 206 // Destruction | |
| 207 ~VirtualSpace(); | |
| 208 | |
| 209 // Testers (all sizes are byte sizes) | |
| 210 size_t committed_size() const; | |
| 211 size_t reserved_size() const; | |
| 212 size_t uncommitted_size() const; | |
| 213 bool contains(const void* p) const; | |
| 214 | |
| 215 // Operations | |
| 216 // returns true on success, false otherwise | |
| 217 bool expand_by(size_t bytes, bool pre_touch = false); | |
| 218 void shrink_by(size_t bytes); | |
| 219 void release(); | |
| 220 | |
| 221 void check_for_contiguity() PRODUCT_RETURN; | |
| 222 | |
| 223 // Debugging | |
| 224 void print() PRODUCT_RETURN; | |
| 225 }; |