153 } |
153 } |
154 } |
154 } |
155 return true; |
155 return true; |
156 } |
156 } |
157 |
157 |
158 ReservedSpace::ReservedSpace(const size_t prefix_size, |
158 ReservedSpace::ReservedSpace(const size_t suffix_size, |
159 const size_t prefix_align, |
|
160 const size_t suffix_size, |
|
161 const size_t suffix_align, |
159 const size_t suffix_align, |
162 char* requested_address, |
160 char* requested_address, |
163 const size_t noaccess_prefix) |
161 const size_t noaccess_prefix) |
164 { |
162 { |
165 assert(prefix_size != 0, "sanity"); |
|
166 assert(prefix_align != 0, "sanity"); |
|
167 assert(suffix_size != 0, "sanity"); |
163 assert(suffix_size != 0, "sanity"); |
168 assert(suffix_align != 0, "sanity"); |
164 assert(suffix_align != 0, "sanity"); |
169 assert((prefix_size & (prefix_align - 1)) == 0, |
|
170 "prefix_size not divisible by prefix_align"); |
|
171 assert((suffix_size & (suffix_align - 1)) == 0, |
165 assert((suffix_size & (suffix_align - 1)) == 0, |
172 "suffix_size not divisible by suffix_align"); |
166 "suffix_size not divisible by suffix_align"); |
173 assert((suffix_align & (prefix_align - 1)) == 0, |
|
174 "suffix_align not divisible by prefix_align"); |
|
175 |
167 |
176 // Assert that if noaccess_prefix is used, it is the same as prefix_align. |
168 // Assert that if noaccess_prefix is used, it is the same as prefix_align. |
177 assert(noaccess_prefix == 0 || |
169 // Add in noaccess_prefix to prefix |
178 noaccess_prefix == prefix_align, "noaccess prefix wrong"); |
170 const size_t adjusted_prefix_size = noaccess_prefix; |
179 |
|
180 // Add in noaccess_prefix to prefix_size; |
|
181 const size_t adjusted_prefix_size = prefix_size + noaccess_prefix; |
|
182 const size_t size = adjusted_prefix_size + suffix_size; |
171 const size_t size = adjusted_prefix_size + suffix_size; |
183 |
172 |
184 // On systems where the entire region has to be reserved and committed up |
173 // On systems where the entire region has to be reserved and committed up |
185 // front, the compound alignment normally done by this method is unnecessary. |
174 // front, the compound alignment normally done by this method is unnecessary. |
186 const bool try_reserve_special = UseLargePages && |
175 const bool try_reserve_special = UseLargePages && |
187 prefix_align == os::large_page_size(); |
176 suffix_align == os::large_page_size(); |
188 if (!os::can_commit_large_page_memory() && try_reserve_special) { |
177 if (!os::can_commit_large_page_memory() && try_reserve_special) { |
189 initialize(size, prefix_align, true, requested_address, noaccess_prefix, |
178 initialize(size, suffix_align, true, requested_address, noaccess_prefix, |
190 false); |
179 false); |
191 return; |
180 return; |
192 } |
181 } |
193 |
182 |
194 _base = NULL; |
183 _base = NULL; |
207 if (failed_to_reserve_as_requested(addr, requested_address, size, false)) { |
196 if (failed_to_reserve_as_requested(addr, requested_address, size, false)) { |
208 // OS ignored requested address. Try different address. |
197 // OS ignored requested address. Try different address. |
209 addr = NULL; |
198 addr = NULL; |
210 } |
199 } |
211 } else { |
200 } else { |
212 addr = os::reserve_memory(size, NULL, prefix_align); |
201 addr = os::reserve_memory(size, NULL, suffix_align); |
213 } |
202 } |
214 if (addr == NULL) return; |
203 if (addr == NULL) return; |
215 |
204 |
216 // Check whether the result has the needed alignment (unlikely unless |
205 // Check whether the result has the needed alignment |
217 // prefix_align < suffix_align). |
|
218 const size_t ofs = (size_t(addr) + adjusted_prefix_size) & (suffix_align - 1); |
206 const size_t ofs = (size_t(addr) + adjusted_prefix_size) & (suffix_align - 1); |
219 if (ofs != 0) { |
207 if (ofs != 0) { |
220 // Wrong alignment. Release, allocate more space and do manual alignment. |
208 // Wrong alignment. Release, allocate more space and do manual alignment. |
221 // |
209 // |
222 // On most operating systems, another allocation with a somewhat larger size |
210 // On most operating systems, another allocation with a somewhat larger size |
227 if (!os::release_memory(addr, size)) { |
215 if (!os::release_memory(addr, size)) { |
228 fatal("os::release_memory failed"); |
216 fatal("os::release_memory failed"); |
229 } |
217 } |
230 |
218 |
231 const size_t extra = MAX2(ofs, suffix_align - ofs); |
219 const size_t extra = MAX2(ofs, suffix_align - ofs); |
232 addr = reserve_and_align(size + extra, adjusted_prefix_size, prefix_align, |
220 addr = reserve_and_align(size + extra, adjusted_prefix_size, suffix_align, |
233 suffix_size, suffix_align); |
221 suffix_size, suffix_align); |
234 if (addr == NULL) { |
222 if (addr == NULL) { |
235 // Try an even larger region. If this fails, address space is exhausted. |
223 // Try an even larger region. If this fails, address space is exhausted. |
236 addr = reserve_and_align(size + suffix_align, adjusted_prefix_size, |
224 addr = reserve_and_align(size + suffix_align, adjusted_prefix_size, |
237 prefix_align, suffix_size, suffix_align); |
225 suffix_align, suffix_size, suffix_align); |
238 } |
226 } |
239 |
227 |
240 if (requested_address != 0 && |
228 if (requested_address != 0 && |
241 failed_to_reserve_as_requested(addr, requested_address, size, false)) { |
229 failed_to_reserve_as_requested(addr, requested_address, size, false)) { |
242 // As a result of the alignment constraints, the allocated addr differs |
230 // As a result of the alignment constraints, the allocated addr differs |
497 // Only reserved space for the java heap should have a noaccess_prefix |
485 // Only reserved space for the java heap should have a noaccess_prefix |
498 // if using compressed oops. |
486 // if using compressed oops. |
499 protect_noaccess_prefix(size); |
487 protect_noaccess_prefix(size); |
500 } |
488 } |
501 |
489 |
502 ReservedHeapSpace::ReservedHeapSpace(const size_t prefix_size, |
490 ReservedHeapSpace::ReservedHeapSpace(const size_t heap_space_size, |
503 const size_t prefix_align, |
491 const size_t alignment, |
504 const size_t suffix_size, |
|
505 const size_t suffix_align, |
|
506 char* requested_address) : |
492 char* requested_address) : |
507 ReservedSpace(prefix_size, prefix_align, suffix_size, suffix_align, |
493 ReservedSpace(heap_space_size, alignment, |
508 requested_address, |
494 requested_address, |
509 (UseCompressedOops && (Universe::narrow_oop_base() != NULL) && |
495 (UseCompressedOops && (Universe::narrow_oop_base() != NULL) && |
510 Universe::narrow_oop_use_implicit_null_checks()) ? |
496 Universe::narrow_oop_use_implicit_null_checks()) ? |
511 lcm(os::vm_page_size(), prefix_align) : 0) { |
497 lcm(os::vm_page_size(), alignment) : 0) { |
512 if (base() > 0) { |
498 if (base() > 0) { |
513 MemTracker::record_virtual_memory_type((address)base(), mtJavaHeap); |
499 MemTracker::record_virtual_memory_type((address)base(), mtJavaHeap); |
514 } |
500 } |
515 |
501 protect_noaccess_prefix(heap_space_size); |
516 protect_noaccess_prefix(prefix_size+suffix_size); |
|
517 } |
502 } |
518 |
503 |
519 // Reserve space for code segment. Same as Java heap only we mark this as |
504 // Reserve space for code segment. Same as Java heap only we mark this as |
520 // executable. |
505 // executable. |
521 ReservedCodeSpace::ReservedCodeSpace(size_t r_size, |
506 ReservedCodeSpace::ReservedCodeSpace(size_t r_size, |