53 } else {
54 // Don't force the alignment to be large page aligned,
55 // since that will waste memory.
56 alignment = os::vm_allocation_granularity();
57 }
58 initialize(size, alignment, large_pages, NULL, false);
59 }
60
61 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
62 bool large,
63 char* requested_address) : _fd_for_heap(-1) {
64 initialize(size, alignment, large, requested_address, false);
65 }
66
67 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
68 bool large,
69 bool executable) : _fd_for_heap(-1) {
70 initialize(size, alignment, large, NULL, executable);
71 }
72
73 // Helper method
74 static void unmap_or_release_memory(char* base, size_t size, bool is_file_mapped) {
75 if (is_file_mapped) {
76 if (!os::unmap_memory(base, size)) {
77 fatal("os::unmap_memory failed");
78 }
79 } else if (!os::release_memory(base, size)) {
80 fatal("os::release_memory failed");
81 }
82 }
83
84 // Helper method.
85 static bool failed_to_reserve_as_requested(char* base, char* requested_address,
86 const size_t size, bool special, bool is_file_mapped = false)
87 {
88 if (base == requested_address || requested_address == NULL)
89 return false; // did not fail
90
91 if (base != NULL) {
92 // Different reserve address may be acceptable in other cases
200
201 if (requested_address != 0 &&
202 failed_to_reserve_as_requested(base, requested_address, size, false, _fd_for_heap != -1)) {
203 // As a result of the alignment constraints, the allocated base differs
204 // from the requested address. Return back to the caller who can
205 // take remedial action (like try again without a requested address).
206 assert(_base == NULL, "should be");
207 return;
208 }
209 }
210 }
211 // Done
212 _base = base;
213 _size = size;
214 _alignment = alignment;
215 // If heap is reserved with a backing file, the entire space has been committed. So set the _special flag to true
216 if (_fd_for_heap != -1) {
217 _special = true;
218 }
219 }
220
221
222 ReservedSpace::ReservedSpace(char* base, size_t size, size_t alignment,
223 bool special, bool executable) {
224 assert((size % os::vm_allocation_granularity()) == 0,
225 "size not allocation aligned");
226 _base = base;
227 _size = size;
228 _alignment = alignment;
229 _noaccess_prefix = 0;
230 _special = special;
231 _executable = executable;
232 }
233
234
235 ReservedSpace ReservedSpace::first_part(size_t partition_size, size_t alignment,
236 bool split, bool realloc) {
237 assert(partition_size <= size(), "partition failed");
238 if (split) {
239 os::split_reserved_memory(base(), size(), partition_size, realloc);
240 }
241 ReservedSpace result(base(), partition_size, alignment, special(),
242 executable());
243 return result;
244 }
245
246
247 ReservedSpace
248 ReservedSpace::last_part(size_t partition_size, size_t alignment) {
249 assert(partition_size <= size(), "partition failed");
250 ReservedSpace result(base() + partition_size, size() - partition_size,
251 alignment, special(), executable());
252 return result;
253 }
|
53 } else {
54 // Don't force the alignment to be large page aligned,
55 // since that will waste memory.
56 alignment = os::vm_allocation_granularity();
57 }
58 initialize(size, alignment, large_pages, NULL, false);
59 }
60
61 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
62 bool large,
63 char* requested_address) : _fd_for_heap(-1) {
64 initialize(size, alignment, large, requested_address, false);
65 }
66
67 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
68 bool large,
69 bool executable) : _fd_for_heap(-1) {
70 initialize(size, alignment, large, NULL, executable);
71 }
72
73 ReservedSpace::ReservedSpace(char* base, size_t size, size_t alignment,
74 bool special, bool executable) : _fd_for_heap(-1) {
75 assert((size % os::vm_allocation_granularity()) == 0,
76 "size not allocation aligned");
77 _base = base;
78 _size = size;
79 _alignment = alignment;
80 _noaccess_prefix = 0;
81 _special = special;
82 _executable = executable;
83 }
84
85 // Helper method
86 static void unmap_or_release_memory(char* base, size_t size, bool is_file_mapped) {
87 if (is_file_mapped) {
88 if (!os::unmap_memory(base, size)) {
89 fatal("os::unmap_memory failed");
90 }
91 } else if (!os::release_memory(base, size)) {
92 fatal("os::release_memory failed");
93 }
94 }
95
96 // Helper method.
97 static bool failed_to_reserve_as_requested(char* base, char* requested_address,
98 const size_t size, bool special, bool is_file_mapped = false)
99 {
100 if (base == requested_address || requested_address == NULL)
101 return false; // did not fail
102
103 if (base != NULL) {
104 // Different reserve address may be acceptable in other cases
212
213 if (requested_address != 0 &&
214 failed_to_reserve_as_requested(base, requested_address, size, false, _fd_for_heap != -1)) {
215 // As a result of the alignment constraints, the allocated base differs
216 // from the requested address. Return back to the caller who can
217 // take remedial action (like try again without a requested address).
218 assert(_base == NULL, "should be");
219 return;
220 }
221 }
222 }
223 // Done
224 _base = base;
225 _size = size;
226 _alignment = alignment;
227 // If heap is reserved with a backing file, the entire space has been committed. So set the _special flag to true
228 if (_fd_for_heap != -1) {
229 _special = true;
230 }
231 }
232
233 ReservedSpace ReservedSpace::first_part(size_t partition_size, size_t alignment,
234 bool split, bool realloc) {
235 assert(partition_size <= size(), "partition failed");
236 if (split) {
237 os::split_reserved_memory(base(), size(), partition_size, realloc);
238 }
239 ReservedSpace result(base(), partition_size, alignment, special(),
240 executable());
241 return result;
242 }
243
244
245 ReservedSpace
246 ReservedSpace::last_part(size_t partition_size, size_t alignment) {
247 assert(partition_size <= size(), "partition failed");
248 ReservedSpace result(base() + partition_size, size() - partition_size,
249 alignment, special(), executable());
250 return result;
251 }
|