Mercurial > hg > graal-jvmci-8

comparison src/share/vm/runtime/virtualspace.cpp @ 6725:da91efe96a93

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author coleenp
date Sat, 01 Sep 2012 13:25:18 -0400
parents d2a62e0f25eb
children 730cc4ddd550
comparison
equal deleted inserted replaced
6724:36d1d483d5d6 6725:da91efe96a93
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
247 } 235 }
248 } 236 }
249 237
250 _base = addr; 238 _base = addr;
251 _size = size; 239 _size = size;
252 _alignment = prefix_align; 240 _alignment = suffix_align;
253 _noaccess_prefix = noaccess_prefix; 241 _noaccess_prefix = noaccess_prefix;
254 } 242 }
255 243
256 void ReservedSpace::initialize(size_t size, size_t alignment, bool large, 244 void ReservedSpace::initialize(size_t size, size_t alignment, bool large,
257 char* requested_address, 245 char* requested_address,
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,