truffle: src/share/vm/runtime/virtualspace.cpp comparison

comparison src/share/vm/runtime/virtualspace.cpp @ 656:6bdd6923ba16

6541756: Reduce executable C-heap Summary: Add executable parameters to reserve_memory and commit_memory to reduce executable memory to only the Code Heap. Reviewed-by: xlu, kvn, acorn

author	coleenp
date	Wed, 25 Mar 2009 14:19:20 -0400
parents	660978a2a31a
children	bd02caa94611

comparison

equal deleted inserted replaced

-:60bfce711da4
+:6bdd6923ba16
 #include "incls/_virtualspace.cpp.incl"
 // ReservedSpace
 ReservedSpace::ReservedSpace(size_t size) {
-initialize(size, 0, false, NULL, 0);
+initialize(size, 0, false, NULL, 0, false);
 }
 ReservedSpace::ReservedSpace(size_t size, size_t alignment,
 bool large,
 char* requested_address,
 const size_t noaccess_prefix) {
 initialize(size+noaccess_prefix, alignment, large, requested_address,
-noaccess_prefix);
+noaccess_prefix, false);
+}
+ReservedSpace::ReservedSpace(size_t size, size_t alignment,
+bool large,
+bool executable) {
+initialize(size, alignment, large, NULL, 0, executable);
 }
 char *
 ReservedSpace::align_reserved_region(char* addr, const size_t len,
 const size_t prefix_size,
 // On systems where the entire region has to be reserved and committed up
 // front, the compound alignment normally done by this method is unnecessary.
 const bool try_reserve_special = UseLargePages &&
 prefix_align == os::large_page_size();
 if (!os::can_commit_large_page_memory() && try_reserve_special) {
-initialize(size, prefix_align, true, requested_address, noaccess_prefix);
+initialize(size, prefix_align, true, requested_address, noaccess_prefix,
+false);
 return;
 }
 _base = NULL;
 _size = 0;
 _alignment = 0;
 _special = false;
 _noaccess_prefix = 0;
+_executable = false;
 // Assert that if noaccess_prefix is used, it is the same as prefix_align.
 assert(noaccess_prefix == 0 ||
 noaccess_prefix == prefix_align, "noaccess prefix wrong");
 _noaccess_prefix = noaccess_prefix;
 }
 void ReservedSpace::initialize(size_t size, size_t alignment, bool large,
 char* requested_address,
-const size_t noaccess_prefix) {
+const size_t noaccess_prefix,
+bool executable) {
 const size_t granularity = os::vm_allocation_granularity();
 assert((size & granularity - 1) == 0,
 "size not aligned to os::vm_allocation_granularity()");
 assert((alignment & granularity - 1) == 0,
 "alignment not aligned to os::vm_allocation_granularity()");
 "not a power of 2");
 _base = NULL;
 _size = 0;
 _special = false;
+_executable = executable;
 _alignment = 0;
 _noaccess_prefix = 0;
 if (size == 0) {
 return;
 }
 bool special = large && !os::can_commit_large_page_memory();
 char* base = NULL;
 if (special) {
-base = os::reserve_memory_special(size, requested_address);
+base = os::reserve_memory_special(size, requested_address, executable);
 if (base != NULL) {
 // Check alignment constraints
 if (alignment > 0) {
 assert((uintptr_t) base % alignment == 0,
 "area must be distinguisable from marks for mark-sweep");
 }
 ReservedSpace::ReservedSpace(char* base, size_t size, size_t alignment,
-bool special) {
+bool special, bool executable) {
 assert((size % os::vm_allocation_granularity()) == 0,
 "size not allocation aligned");
 _base = base;
 _size = size;
 _alignment = alignment;
 _noaccess_prefix = 0;
 _special = special;
+_executable = executable;
 }
 ReservedSpace ReservedSpace::first_part(size_t partition_size, size_t alignment,
 bool split, bool realloc) {
 assert(partition_size <= size(), "partition failed");
 if (split) {
-os::split_reserved_memory(_base, _size, partition_size, realloc);
+os::split_reserved_memory(base(), size(), partition_size, realloc);
 }
-ReservedSpace result(base(), partition_size, alignment, special());
+ReservedSpace result(base(), partition_size, alignment, special(),
+executable());
 return result;
 }
 ReservedSpace
 ReservedSpace::last_part(size_t partition_size, size_t alignment) {
 assert(partition_size <= size(), "partition failed");
 ReservedSpace result(base() + partition_size, size() - partition_size,
-alignment, special());
+alignment, special(), executable());
 return result;
 }
 size_t ReservedSpace::page_align_size_up(size_t size) {
 }
 _base = NULL;
 _size = 0;
 _noaccess_prefix = 0;
 _special = false;
+_executable = false;
 }
 }
 void ReservedSpace::protect_noaccess_prefix(const size_t size) {
 // If there is noaccess prefix, return.
 requested_address,
 (UseCompressedOops && (Universe::narrow_oop_base() != NULL) &&
 Universe::narrow_oop_use_implicit_null_checks()) ?
 lcm(os::vm_page_size(), prefix_align) : 0) {
 protect_noaccess_prefix(prefix_size+suffix_size);
+}
+// Reserve space for code segment.  Same as Java heap only we mark this as
+// executable.
+ReservedCodeSpace::ReservedCodeSpace(size_t r_size,
+size_t rs_align,
+bool large) :
+ReservedSpace(r_size, rs_align, large, /*executable*/ true) {
 }
 // VirtualSpace
 VirtualSpace::VirtualSpace() {
 _upper_high_boundary    = NULL;
 _lower_alignment        = 0;
 _middle_alignment       = 0;
 _upper_alignment        = 0;
 _special                = false;
+_executable             = false;
 }
 bool VirtualSpace::initialize(ReservedSpace rs, size_t committed_size) {
 if(!rs.is_reserved()) return false;  // allocation failed.
 _low = low_boundary();
 _high = low();
 _special = rs.special();
+_executable = rs.executable();
 // When a VirtualSpace begins life at a large size, make all future expansion
 // and shrinking occur aligned to a granularity of large pages.  This avoids
 // fragmentation of physical addresses that inhibits the use of large pages
 // by the OS virtual memory system.  Empirically,  we see that with a 4MB
 _upper_high_boundary    = NULL;
 _lower_alignment        = 0;
 _middle_alignment       = 0;
 _upper_alignment        = 0;
 _special                = false;
+_executable             = false;
 }
 size_t VirtualSpace::committed_size() const {
 return pointer_delta(high(), low(), sizeof(char));
 // Commit regions
 if (lower_needs > 0) {
 assert(low_boundary() <= lower_high() &&
 lower_high() + lower_needs <= lower_high_boundary(),
 "must not expand beyond region");
-if (!os::commit_memory(lower_high(), lower_needs)) {
+if (!os::commit_memory(lower_high(), lower_needs, _executable)) {
 debug_only(warning("os::commit_memory failed"));
 return false;
 } else {
 _lower_high += lower_needs;
 }
 }
 if (middle_needs > 0) {
 assert(lower_high_boundary() <= middle_high() &&
 middle_high() + middle_needs <= middle_high_boundary(),
 "must not expand beyond region");
-if (!os::commit_memory(middle_high(), middle_needs, middle_alignment())) {
+if (!os::commit_memory(middle_high(), middle_needs, middle_alignment(),
+_executable)) {
 debug_only(warning("os::commit_memory failed"));
 return false;
 }
 _middle_high += middle_needs;
 }
 if (upper_needs > 0) {
 assert(middle_high_boundary() <= upper_high() &&
 upper_high() + upper_needs <= upper_high_boundary(),
 "must not expand beyond region");
-if (!os::commit_memory(upper_high(), upper_needs)) {
+if (!os::commit_memory(upper_high(), upper_needs, _executable)) {
 debug_only(warning("os::commit_memory failed"));
 return false;
 } else {
 _upper_high += upper_needs;
 }

Mercurial > hg > truffle

comparison src/share/vm/runtime/virtualspace.cpp @ 656:6bdd6923ba16