void G1PageBasedVirtualSpace::print_on(outputStream* out) { out->print ("Virtual space:"); if (special()) out->print(" (pinned in memory)"); out->cr(); out->print_cr(" - committed: " SIZE_FORMAT, committed_size()); out->print_cr(" - reserved: " SIZE_FORMAT, reserved_size()); out->print_cr(" - [low_b, high_b]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]", p2i(_low_boundary), p2i(_high_boundary)); }
void ReservedMemoryRegion::set_flag(MEMFLAGS f) { assert((flag() == mtNone || flag() == f), "Overwrite memory type"); if (flag() != f) { VirtualMemorySummary::move_reserved_memory(flag(), f, size()); VirtualMemorySummary::move_committed_memory(flag(), f, committed_size()); _flag = f; } }
void VirtualSpace::print() { tty->print ("Virtual space:"); if (special()) tty->print(" (pinned in memory)"); tty->cr(); tty->print_cr(" - committed: " SIZE_FORMAT, committed_size()); tty->print_cr(" - reserved: " SIZE_FORMAT, reserved_size()); tty->print_cr(" - [low, high]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]", low(), high()); tty->print_cr(" - [low_b, high_b]: [" INTPTR_FORMAT ", " INTPTR_FORMAT "]", low_boundary(), high_boundary()); }
bool PSVirtualSpaceHighToLow::shrink_by(size_t bytes) { assert(is_aligned(bytes), "arg not aligned"); DEBUG_ONLY(PSVirtualSpaceVerifier this_verifier(this)); if (committed_size() < bytes) { return false; } char* const base_addr = committed_low_addr(); os::uncommit_memory(base_addr,bytes,Modules::ParGC_PSVirtualSpace); return true; }
void PSVirtualSpace::print() const { gclog_or_tty->print_cr("virtual space [" PTR_FORMAT "]: alignment=" SIZE_FORMAT "K grows %s", this, alignment() / K, grows_up() ? "up" : "down"); gclog_or_tty->print_cr(" reserved=" SIZE_FORMAT "K" " [" PTR_FORMAT "," PTR_FORMAT "]" " committed=" SIZE_FORMAT "K" " [" PTR_FORMAT "," PTR_FORMAT "]", reserved_size() / K, reserved_low_addr(), reserved_high_addr(), committed_size() / K, committed_low_addr(), committed_high_addr()); }
void PSVirtualSpace::print() const { gclog_or_tty->print_cr("virtual space [" PTR_FORMAT "]: alignment=" SIZE_FORMAT "K grows %s%s", p2i(this), alignment() / K, grows_up() ? "up" : "down", special() ? " (pinned in memory)" : ""); gclog_or_tty->print_cr(" reserved=" SIZE_FORMAT "K" " [" PTR_FORMAT "," PTR_FORMAT "]" " committed=" SIZE_FORMAT "K" " [" PTR_FORMAT "," PTR_FORMAT "]", reserved_size() / K, p2i(reserved_low_addr()), p2i(reserved_high_addr()), committed_size() / K, p2i(committed_low_addr()), p2i(committed_high_addr())); }
bool PSVirtualSpaceHighToLow::shrink_by(size_t bytes) { assert(is_aligned(bytes), "arg not aligned"); DEBUG_ONLY(PSVirtualSpaceVerifier this_verifier(this)); if (committed_size() < bytes) { return false; } char* const base_addr = committed_low_addr(); bool result = special() || os::uncommit_memory(base_addr, bytes); if (result) { _committed_low_addr += bytes; } return result; }
size_t G1PageBasedVirtualSpace::uncommitted_size() const { return reserved_size() - committed_size(); }
inline size_t PSVirtualSpace::uncommitted_size() const { return reserved_size() - committed_size(); }
// A page is uncommitted if the contents of the entire page is deemed unusable. // Continue to decrement the high() pointer until it reaches a page boundary // in which case that particular page can now be uncommitted. void VirtualSpace::shrink_by(size_t size) { if (committed_size() < size) fatal("Cannot shrink virtual space to negative size"); if (special()) { // don't uncommit if the entire space is pinned in memory _high -= size; return; } char* unaligned_new_high = high() - size; assert(unaligned_new_high >= low_boundary(), "cannot shrink past lower boundary"); // Calculate new unaligned address char* unaligned_upper_new_high = MAX2(unaligned_new_high, middle_high_boundary()); char* unaligned_middle_new_high = MAX2(unaligned_new_high, lower_high_boundary()); char* unaligned_lower_new_high = MAX2(unaligned_new_high, low_boundary()); // Align address to region's alignment char* aligned_upper_new_high = (char*) round_to((intptr_t) unaligned_upper_new_high, upper_alignment()); char* aligned_middle_new_high = (char*) round_to((intptr_t) unaligned_middle_new_high, middle_alignment()); char* aligned_lower_new_high = (char*) round_to((intptr_t) unaligned_lower_new_high, lower_alignment()); // Determine which regions need to shrink size_t upper_needs = 0; if (aligned_upper_new_high < upper_high()) { upper_needs = pointer_delta(upper_high(), aligned_upper_new_high, sizeof(char)); } size_t middle_needs = 0; if (aligned_middle_new_high < middle_high()) { middle_needs = pointer_delta(middle_high(), aligned_middle_new_high, sizeof(char)); } size_t lower_needs = 0; if (aligned_lower_new_high < lower_high()) { lower_needs = pointer_delta(lower_high(), aligned_lower_new_high, sizeof(char)); } // Check contiguity. assert(middle_high_boundary() <= upper_high() && upper_high() <= upper_high_boundary(), "high address must be contained within the region"); assert(lower_high_boundary() <= middle_high() && middle_high() <= middle_high_boundary(), "high address must be contained within the region"); assert(low_boundary() <= lower_high() && lower_high() <= lower_high_boundary(), "high address must be contained within the region"); // Uncommit if (upper_needs > 0) { assert(middle_high_boundary() <= aligned_upper_new_high && aligned_upper_new_high + upper_needs <= upper_high_boundary(), "must not shrink beyond region"); if (!os::uncommit_memory(aligned_upper_new_high, upper_needs)) { debug_only(warning("os::uncommit_memory failed")); return; } else { _upper_high -= upper_needs; } } if (middle_needs > 0) { assert(lower_high_boundary() <= aligned_middle_new_high && aligned_middle_new_high + middle_needs <= middle_high_boundary(), "must not shrink beyond region"); if (!os::uncommit_memory(aligned_middle_new_high, middle_needs)) { debug_only(warning("os::uncommit_memory failed")); return; } else { _middle_high -= middle_needs; } } if (lower_needs > 0) { assert(low_boundary() <= aligned_lower_new_high && aligned_lower_new_high + lower_needs <= lower_high_boundary(), "must not shrink beyond region"); if (!os::uncommit_memory(aligned_lower_new_high, lower_needs)) { debug_only(warning("os::uncommit_memory failed")); return; } else { _lower_high -= lower_needs; } } _high -= size; }