Mercurial > hg > truffle
annotate src/share/vm/runtime/virtualspace.hpp @ 2368:dde920245681
6896099: Integrate CMS heap ergo with default heap sizing ergo
6627787: CMS: JVM refuses to start up with -Xms16m -Xmx16m
7000125: CMS: Anti-monotone young gen sizing with respect to maximum whole heap size specification
7027529: CMS: retire CMSUseOldDefaults flag
Summary: Simplify CMS heap sizing code, relying on ergonomic initial sizing consistent with other collectors for the most part, controlling only young gen sizing to rein in pause times. Make CMS young gen sizing default statically cpu-dependant. Remove inconsistencies wrt generation sizing and policy code, allowing for the fixing for 6627787 and 7000125. For 7027529, retire the flag CMSUseOldDefaults which had been introduced as a bridge from JDK 5 to JDK 6 a number of years ago.
Reviewed-by: brutisso, poonam
author | ysr |
---|---|
date | Wed, 16 Mar 2011 10:37:08 -0700 |
parents | f95d63e2154a |
children | da91efe96a93 |
rev | line source |
---|---|
0 | 1 /* |
1972 | 2 * Copyright (c) 1997, 2010, 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); |
0 | 82 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
|
83 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
|
84 char* requested_address, |
660978a2a31a
6791178: Specialize for zero as the compressed oop vm heap base
kvn
parents:
337
diff
changeset
|
85 const size_t noaccess_prefix = 0); |
656 | 86 ReservedSpace(size_t size, size_t alignment, bool large, bool executable); |
0 | 87 |
88 // Accessors | |
656 | 89 char* base() const { return _base; } |
90 size_t size() const { return _size; } | |
91 size_t alignment() const { return _alignment; } | |
92 bool special() const { return _special; } | |
93 bool executable() const { return _executable; } | |
94 size_t noaccess_prefix() const { return _noaccess_prefix; } | |
95 bool is_reserved() const { return _base != NULL; } | |
0 | 96 void release(); |
97 | |
98 // Splitting | |
99 ReservedSpace first_part(size_t partition_size, size_t alignment, | |
100 bool split = false, bool realloc = true); | |
101 ReservedSpace last_part (size_t partition_size, size_t alignment); | |
102 | |
103 // These simply call the above using the default alignment. | |
104 inline ReservedSpace first_part(size_t partition_size, | |
105 bool split = false, bool realloc = true); | |
106 inline ReservedSpace last_part (size_t partition_size); | |
107 | |
108 // Alignment | |
109 static size_t page_align_size_up(size_t size); | |
110 static size_t page_align_size_down(size_t size); | |
111 static size_t allocation_align_size_up(size_t size); | |
112 static size_t allocation_align_size_down(size_t size); | |
113 }; | |
114 | |
115 ReservedSpace | |
116 ReservedSpace::first_part(size_t partition_size, bool split, bool realloc) | |
117 { | |
118 return first_part(partition_size, alignment(), split, realloc); | |
119 } | |
120 | |
121 ReservedSpace ReservedSpace::last_part(size_t partition_size) | |
122 { | |
123 return last_part(partition_size, alignment()); | |
124 } | |
125 | |
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
126 // 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
|
127 class ReservedHeapSpace : public ReservedSpace { |
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
128 public: |
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
129 // Constructor |
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
130 ReservedHeapSpace(size_t size, size_t forced_base_alignment, |
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
131 bool large, char* requested_address); |
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
132 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
|
133 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
|
134 char* requested_address); |
237
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
135 }; |
1fdb98a17101
6716785: implicit null checks not triggering with CompressedOops
coleenp
parents:
0
diff
changeset
|
136 |
656 | 137 // Class encapsulating behavior specific memory space for Code |
138 class ReservedCodeSpace : public ReservedSpace { | |
139 public: | |
140 // Constructor | |
141 ReservedCodeSpace(size_t r_size, size_t rs_align, bool large); | |
142 }; | |
143 | |
0 | 144 // VirtualSpace is data structure for committing a previously reserved address range in smaller chunks. |
145 | |
146 class VirtualSpace VALUE_OBJ_CLASS_SPEC { | |
147 friend class VMStructs; | |
148 private: | |
149 // Reserved area | |
150 char* _low_boundary; | |
151 char* _high_boundary; | |
152 | |
153 // Committed area | |
154 char* _low; | |
155 char* _high; | |
156 | |
157 // The entire space has been committed and pinned in memory, no | |
158 // os::commit_memory() or os::uncommit_memory(). | |
159 bool _special; | |
160 | |
656 | 161 // Need to know if commit should be executable. |
162 bool _executable; | |
163 | |
0 | 164 // MPSS Support |
165 // Each virtualspace region has a lower, middle, and upper region. | |
166 // Each region has an end boundary and a high pointer which is the | |
167 // high water mark for the last allocated byte. | |
168 // The lower and upper unaligned to LargePageSizeInBytes uses default page. | |
169 // size. The middle region uses large page size. | |
170 char* _lower_high; | |
171 char* _middle_high; | |
172 char* _upper_high; | |
173 | |
174 char* _lower_high_boundary; | |
175 char* _middle_high_boundary; | |
176 char* _upper_high_boundary; | |
177 | |
178 size_t _lower_alignment; | |
179 size_t _middle_alignment; | |
180 size_t _upper_alignment; | |
181 | |
182 // MPSS Accessors | |
183 char* lower_high() const { return _lower_high; } | |
184 char* middle_high() const { return _middle_high; } | |
185 char* upper_high() const { return _upper_high; } | |
186 | |
187 char* lower_high_boundary() const { return _lower_high_boundary; } | |
188 char* middle_high_boundary() const { return _middle_high_boundary; } | |
189 char* upper_high_boundary() const { return _upper_high_boundary; } | |
190 | |
191 size_t lower_alignment() const { return _lower_alignment; } | |
192 size_t middle_alignment() const { return _middle_alignment; } | |
193 size_t upper_alignment() const { return _upper_alignment; } | |
194 | |
195 public: | |
196 // Committed area | |
197 char* low() const { return _low; } | |
198 char* high() const { return _high; } | |
199 | |
200 // Reserved area | |
201 char* low_boundary() const { return _low_boundary; } | |
202 char* high_boundary() const { return _high_boundary; } | |
203 | |
204 bool special() const { return _special; } | |
205 | |
206 public: | |
207 // Initialization | |
208 VirtualSpace(); | |
209 bool initialize(ReservedSpace rs, size_t committed_byte_size); | |
210 | |
211 // Destruction | |
212 ~VirtualSpace(); | |
213 | |
214 // Testers (all sizes are byte sizes) | |
215 size_t committed_size() const; | |
216 size_t reserved_size() const; | |
217 size_t uncommitted_size() const; | |
218 bool contains(const void* p) const; | |
219 | |
220 // Operations | |
221 // returns true on success, false otherwise | |
222 bool expand_by(size_t bytes, bool pre_touch = false); | |
223 void shrink_by(size_t bytes); | |
224 void release(); | |
225 | |
226 void check_for_contiguity() PRODUCT_RETURN; | |
227 | |
228 // Debugging | |
229 void print() PRODUCT_RETURN; | |
230 }; | |
1972 | 231 |
232 #endif // SHARE_VM_RUNTIME_VIRTUALSPACE_HPP |