Cross Reference: /openjdk7/hotspot/src/share/vm/runtime/virtualspace.cpp

Lines Matching refs:size
45 ReservedSpace::ReservedSpace(size_t size) {
46   initialize(size, 0, false, NULL, 0, false);
49 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
53   initialize(size+noaccess_prefix, alignment, large, requested_address,
57 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
60   initialize(size, alignment, large, NULL, 0, executable);
160                                                    const size_t size,
176       if (!os::release_memory_special(base, size)) {
180       release_memory(base, size);
212   const size_t size = adjusted_prefix_size + suffix_size;
219     initialize(size, prefix_align, true, requested_address, noaccess_prefix,
231   // Optimistically try to reserve the exact size needed.
236     addr = os::attempt_reserve_memory_at(size, requested_address);
237     if (failed_to_reserve_as_requested(addr, requested_address, size, false)) {
242     addr = os::reserve_memory(size, NULL, prefix_align);
252     // On most operating systems, another allocation with a somewhat larger size
256     // in size.  Exploit that to minimize the amount of extra space requested.
257     release_memory(addr, size);
260     addr = reserve_and_align(size + extra, adjusted_prefix_size, prefix_align,
264       addr = reserve_and_align(size + suffix_align, adjusted_prefix_size,
269         failed_to_reserve_as_requested(addr, requested_address, size, false)) {
279   _size = size;
284 void ReservedSpace::initialize(size_t size, size_t alignment, bool large,
289   assert((size & (granularity - 1)) == 0,
290          "size not aligned to os::vm_allocation_granularity()");
310   if (size == 0) {
326     base = os::reserve_memory_special(size, requested_address, executable);
329       if (failed_to_reserve_as_requested(base, requested_address, size, true)) {
359       base = os::attempt_reserve_memory_at(size, requested_address);
360       if (failed_to_reserve_as_requested(base, requested_address, size, false)) {
365       base = os::reserve_memory(size, NULL, alignment);
373       release_memory(base, size);
375       // Make sure that size is aligned
376       size = align_size_up(size, alignment);
377       base = os::reserve_memory_aligned(size, alignment);
380           failed_to_reserve_as_requested(base, requested_address, size, false)) {
391   _size = size;
401   assert(markOopDesc::encode_pointer_as_mark(&_base[size])->decode_pointer() == &_base[size],
406 ReservedSpace::ReservedSpace(char* base, size_t size, size_t alignment,
408   assert((size % os::vm_allocation_granularity()) == 0,
409          "size not allocation aligned");
411   _size = size;
422   assert(partition_size <= size(), "partition failed");
424     os::split_reserved_memory(base(), size(), partition_size, realloc);
434   assert(partition_size <= size(), "partition failed");
435   ReservedSpace result(base() + partition_size, size() - partition_size,
441 size_t ReservedSpace::page_align_size_up(size_t size) {
442   return align_size_up(size, os::vm_page_size());
446 size_t ReservedSpace::page_align_size_down(size_t size) {
447   return align_size_down(size, os::vm_page_size());
451 size_t ReservedSpace::allocation_align_size_up(size_t size) {
452   return align_size_up(size, os::vm_allocation_granularity());
456 size_t ReservedSpace::allocation_align_size_down(size_t size) {
457   return align_size_down(size, os::vm_allocation_granularity());
478 void ReservedSpace::protect_noaccess_prefix(const size_t size) {
488          "must be at least page size big");
503   assert((size == _size) && ((uintptr_t)_base % _alignment == 0),
504          "must be exactly of required size and alignment");
507 ReservedHeapSpace::ReservedHeapSpace(size_t size, size_t alignment,
509   ReservedSpace(size, alignment, large,
520   protect_noaccess_prefix(size);
574   _high_boundary = low_boundary() + rs.size();
582   // When a VirtualSpace begins life at a large size, make all future expansion
586   // page size, the only spaces that get handled this way are codecache and
593   _middle_alignment = os::page_size_for_region(rs.size(), rs.size(), 1);
606   // commit to initial size
666    shrink by large page size chunks.  If a particular request
699   // alignment will always be default page size.  middle alignment will be
700   // LargePageSizeInBytes if the actual size of the virtual space is in
711   // region so calcuate the size based on high().  For the middle and
808 void VirtualSpace::shrink_by(size_t size) {
809   if (committed_size() < size)
810     fatal("Cannot shrink virtual space to negative size");
814     _high -= size;
818   char* unaligned_new_high = high() - size;
900   _high -= size;