--- a/hotspot/src/share/vm/memory/metaspace.cpp Fri Oct 11 15:04:53 2013 -0400
+++ b/hotspot/src/share/vm/memory/metaspace.cpp Fri Oct 11 18:23:44 2013 -0700
@@ -29,17 +29,21 @@
#include "memory/collectorPolicy.hpp"
#include "memory/filemap.hpp"
#include "memory/freeList.hpp"
+#include "memory/gcLocker.hpp"
#include "memory/metablock.hpp"
#include "memory/metachunk.hpp"
#include "memory/metaspace.hpp"
#include "memory/metaspaceShared.hpp"
#include "memory/resourceArea.hpp"
#include "memory/universe.hpp"
+#include "runtime/atomic.inline.hpp"
#include "runtime/globals.hpp"
+#include "runtime/init.hpp"
#include "runtime/java.hpp"
#include "runtime/mutex.hpp"
#include "runtime/orderAccess.hpp"
#include "services/memTracker.hpp"
+#include "services/memoryService.hpp"
#include "utilities/copy.hpp"
#include "utilities/debug.hpp"
@@ -84,13 +88,7 @@
return (ChunkIndex) (i+1);
}
-// Originally _capacity_until_GC was set to MetaspaceSize here but
-// the default MetaspaceSize before argument processing was being
-// used which was not the desired value. See the code
-// in should_expand() to see how the initialization is handled
-// now.
-size_t MetaspaceGC::_capacity_until_GC = 0;
-bool MetaspaceGC::_expand_after_GC = false;
+volatile intptr_t MetaspaceGC::_capacity_until_GC = 0;
uint MetaspaceGC::_shrink_factor = 0;
bool MetaspaceGC::_should_concurrent_collect = false;
@@ -293,9 +291,10 @@
MetaWord* end() const { return (MetaWord*) _virtual_space.high(); }
size_t reserved_words() const { return _virtual_space.reserved_size() / BytesPerWord; }
- size_t expanded_words() const { return _virtual_space.committed_size() / BytesPerWord; }
size_t committed_words() const { return _virtual_space.actual_committed_size() / BytesPerWord; }
+ bool is_pre_committed() const { return _virtual_space.special(); }
+
// address of next available space in _virtual_space;
// Accessors
VirtualSpaceNode* next() { return _next; }
@@ -337,7 +336,7 @@
// Expands/shrinks the committed space in a virtual space. Delegates
// to Virtualspace
- bool expand_by(size_t words, bool pre_touch = false);
+ bool expand_by(size_t min_words, size_t preferred_words);
// In preparation for deleting this node, remove all the chunks
// in the node from any freelist.
@@ -351,29 +350,64 @@
void print_on(outputStream* st) const;
};
+#define assert_is_ptr_aligned(ptr, alignment) \
+ assert(is_ptr_aligned(ptr, alignment), \
+ err_msg(PTR_FORMAT " is not aligned to " \
+ SIZE_FORMAT, ptr, alignment))
+
+#define assert_is_size_aligned(size, alignment) \
+ assert(is_size_aligned(size, alignment), \
+ err_msg(SIZE_FORMAT " is not aligned to " \
+ SIZE_FORMAT, size, alignment))
+
+
+// Decide if large pages should be committed when the memory is reserved.
+static bool should_commit_large_pages_when_reserving(size_t bytes) {
+ if (UseLargePages && UseLargePagesInMetaspace && !os::can_commit_large_page_memory()) {
+ size_t words = bytes / BytesPerWord;
+ bool is_class = false; // We never reserve large pages for the class space.
+ if (MetaspaceGC::can_expand(words, is_class) &&
+ MetaspaceGC::allowed_expansion() >= words) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
// byte_size is the size of the associated virtualspace.
-VirtualSpaceNode::VirtualSpaceNode(size_t byte_size) : _top(NULL), _next(NULL), _rs(), _container_count(0) {
- // align up to vm allocation granularity
- byte_size = align_size_up(byte_size, os::vm_allocation_granularity());
+VirtualSpaceNode::VirtualSpaceNode(size_t bytes) : _top(NULL), _next(NULL), _rs(), _container_count(0) {
+ assert_is_size_aligned(bytes, Metaspace::reserve_alignment());
// This allocates memory with mmap. For DumpSharedspaces, try to reserve
// configurable address, generally at the top of the Java heap so other
// memory addresses don't conflict.
if (DumpSharedSpaces) {
- char* shared_base = (char*)SharedBaseAddress;
- _rs = ReservedSpace(byte_size, 0, false, shared_base, 0);
+ bool large_pages = false; // No large pages when dumping the CDS archive.
+ char* shared_base = (char*)align_ptr_up((char*)SharedBaseAddress, Metaspace::reserve_alignment());
+
+ _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages, shared_base, 0);
if (_rs.is_reserved()) {
assert(shared_base == 0 || _rs.base() == shared_base, "should match");
} else {
// Get a mmap region anywhere if the SharedBaseAddress fails.
- _rs = ReservedSpace(byte_size);
+ _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages);
}
MetaspaceShared::set_shared_rs(&_rs);
} else {
- _rs = ReservedSpace(byte_size);
+ bool large_pages = should_commit_large_pages_when_reserving(bytes);
+
+ _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages);
}
- MemTracker::record_virtual_memory_type((address)_rs.base(), mtClass);
+ if (_rs.is_reserved()) {
+ assert(_rs.base() != NULL, "Catch if we get a NULL address");
+ assert(_rs.size() != 0, "Catch if we get a 0 size");
+ assert_is_ptr_aligned(_rs.base(), Metaspace::reserve_alignment());
+ assert_is_size_aligned(_rs.size(), Metaspace::reserve_alignment());
+
+ MemTracker::record_virtual_memory_type((address)_rs.base(), mtClass);
+ }
}
void VirtualSpaceNode::purge(ChunkManager* chunk_manager) {
@@ -410,8 +444,6 @@
#endif
// List of VirtualSpaces for metadata allocation.
-// It has a _next link for singly linked list and a MemRegion
-// for total space in the VirtualSpace.
class VirtualSpaceList : public CHeapObj<mtClass> {
friend class VirtualSpaceNode;
@@ -419,16 +451,13 @@
VirtualSpaceSize = 256 * K
};
- // Global list of virtual spaces
// Head of the list
VirtualSpaceNode* _virtual_space_list;
// virtual space currently being used for allocations
VirtualSpaceNode* _current_virtual_space;
- // Can this virtual list allocate >1 spaces? Also, used to determine
- // whether to allocate unlimited small chunks in this virtual space
+ // Is this VirtualSpaceList used for the compressed class space
bool _is_class;
- bool can_grow() const { return !is_class() || !UseCompressedClassPointers; }
// Sum of reserved and committed memory in the virtual spaces
size_t _reserved_words;
@@ -453,7 +482,7 @@
// Get another virtual space and add it to the list. This
// is typically prompted by a failed attempt to allocate a chunk
// and is typically followed by the allocation of a chunk.
- bool grow_vs(size_t vs_word_size);
+ bool create_new_virtual_space(size_t vs_word_size);
public:
VirtualSpaceList(size_t word_size);
@@ -465,12 +494,12 @@
size_t grow_chunks_by_words,
size_t medium_chunk_bunch);
- bool expand_by(VirtualSpaceNode* node, size_t word_size, bool pre_touch = false);
-
- // Get the first chunk for a Metaspace. Used for
- // special cases such as the boot class loader, reflection
- // class loader and anonymous class loader.
- Metachunk* get_initialization_chunk(size_t word_size, size_t chunk_bunch);
+ bool expand_node_by(VirtualSpaceNode* node,
+ size_t min_words,
+ size_t preferred_words);
+
+ bool expand_by(size_t min_words,
+ size_t preferred_words);
VirtualSpaceNode* current_virtual_space() {
return _current_virtual_space;
@@ -478,8 +507,7 @@
bool is_class() const { return _is_class; }
- // Allocate the first virtualspace.
- void initialize(size_t word_size);
+ bool initialization_succeeded() { return _virtual_space_list != NULL; }
size_t reserved_words() { return _reserved_words; }
size_t reserved_bytes() { return reserved_words() * BytesPerWord; }
@@ -708,6 +736,9 @@
// and allocates from that chunk.
MetaWord* grow_and_allocate(size_t word_size);
+ // Notify memory usage to MemoryService.
+ void track_metaspace_memory_usage();
+
// debugging support.
void dump(outputStream* const out) const;
@@ -869,6 +900,12 @@
MetaWord* chunk_limit = top();
assert(chunk_limit != NULL, "Not safe to call this method");
+ // The virtual spaces are always expanded by the
+ // commit granularity to enforce the following condition.
+ // Without this the is_available check will not work correctly.
+ assert(_virtual_space.committed_size() == _virtual_space.actual_committed_size(),
+ "The committed memory doesn't match the expanded memory.");
+
if (!is_available(chunk_word_size)) {
if (TraceMetadataChunkAllocation) {
gclog_or_tty->print("VirtualSpaceNode::take_from_committed() not available %d words ", chunk_word_size);
@@ -888,14 +925,21 @@
// Expand the virtual space (commit more of the reserved space)
-bool VirtualSpaceNode::expand_by(size_t words, bool pre_touch) {
- size_t bytes = words * BytesPerWord;
- bool result = virtual_space()->expand_by(bytes, pre_touch);
- if (TraceMetavirtualspaceAllocation && !result) {
- gclog_or_tty->print_cr("VirtualSpaceNode::expand_by() failed "
- "for byte size " SIZE_FORMAT, bytes);
- virtual_space()->print_on(gclog_or_tty);
+bool VirtualSpaceNode::expand_by(size_t min_words, size_t preferred_words) {
+ size_t min_bytes = min_words * BytesPerWord;
+ size_t preferred_bytes = preferred_words * BytesPerWord;
+
+ size_t uncommitted = virtual_space()->reserved_size() - virtual_space()->actual_committed_size();
+
+ if (uncommitted < min_bytes) {
+ return false;
}
+
+ size_t commit = MIN2(preferred_bytes, uncommitted);
+ bool result = virtual_space()->expand_by(commit, false);
+
+ assert(result, "Failed to commit memory");
+
return result;
}
@@ -914,12 +958,23 @@
return false;
}
- // An allocation out of this Virtualspace that is larger
- // than an initial commit size can waste that initial committed
- // space.
- size_t committed_byte_size = 0;
- bool result = virtual_space()->initialize(_rs, committed_byte_size);
+ // These are necessary restriction to make sure that the virtual space always
+ // grows in steps of Metaspace::commit_alignment(). If both base and size are
+ // aligned only the middle alignment of the VirtualSpace is used.
+ assert_is_ptr_aligned(_rs.base(), Metaspace::commit_alignment());
+ assert_is_size_aligned(_rs.size(), Metaspace::commit_alignment());
+
+ // ReservedSpaces marked as special will have the entire memory
+ // pre-committed. Setting a committed size will make sure that
+ // committed_size and actual_committed_size agrees.
+ size_t pre_committed_size = _rs.special() ? _rs.size() : 0;
+
+ bool result = virtual_space()->initialize_with_granularity(_rs, pre_committed_size,
+ Metaspace::commit_alignment());
if (result) {
+ assert(virtual_space()->committed_size() == virtual_space()->actual_committed_size(),
+ "Checking that the pre-committed memory was registered by the VirtualSpace");
+
set_top((MetaWord*)virtual_space()->low());
set_reserved(MemRegion((HeapWord*)_rs.base(),
(HeapWord*)(_rs.base() + _rs.size())));
@@ -976,13 +1031,23 @@
_reserved_words = _reserved_words - v;
}
+#define assert_committed_below_limit() \
+ assert(MetaspaceAux::committed_bytes() <= MaxMetaspaceSize, \
+ err_msg("Too much committed memory. Committed: " SIZE_FORMAT \
+ " limit (MaxMetaspaceSize): " SIZE_FORMAT, \
+ MetaspaceAux::committed_bytes(), MaxMetaspaceSize));
+
void VirtualSpaceList::inc_committed_words(size_t v) {
assert_lock_strong(SpaceManager::expand_lock());
_committed_words = _committed_words + v;
+
+ assert_committed_below_limit();
}
void VirtualSpaceList::dec_committed_words(size_t v) {
assert_lock_strong(SpaceManager::expand_lock());
_committed_words = _committed_words - v;
+
+ assert_committed_below_limit();
}
void VirtualSpaceList::inc_virtual_space_count() {
@@ -1025,8 +1090,8 @@
if (vsl->container_count() == 0 && vsl != current_virtual_space()) {
// Unlink it from the list
if (prev_vsl == vsl) {
- // This is the case of the current note being the first note.
- assert(vsl == virtual_space_list(), "Expected to be the first note");
+ // This is the case of the current node being the first node.
+ assert(vsl == virtual_space_list(), "Expected to be the first node");
set_virtual_space_list(vsl->next());
} else {
prev_vsl->set_next(vsl->next());
@@ -1054,7 +1119,7 @@
#endif
}
-VirtualSpaceList::VirtualSpaceList(size_t word_size ) :
+VirtualSpaceList::VirtualSpaceList(size_t word_size) :
_is_class(false),
_virtual_space_list(NULL),
_current_virtual_space(NULL),
@@ -1063,9 +1128,7 @@
_virtual_space_count(0) {
MutexLockerEx cl(SpaceManager::expand_lock(),
Mutex::_no_safepoint_check_flag);
- bool initialization_succeeded = grow_vs(word_size);
- assert(initialization_succeeded,
- " VirtualSpaceList initialization should not fail");
+ create_new_virtual_space(word_size);
}
VirtualSpaceList::VirtualSpaceList(ReservedSpace rs) :
@@ -1079,8 +1142,9 @@
Mutex::_no_safepoint_check_flag);
VirtualSpaceNode* class_entry = new VirtualSpaceNode(rs);
bool succeeded = class_entry->initialize();
- assert(succeeded, " VirtualSpaceList initialization should not fail");
- link_vs(class_entry);
+ if (succeeded) {
+ link_vs(class_entry);
+ }
}
size_t VirtualSpaceList::free_bytes() {
@@ -1088,14 +1152,24 @@
}
// Allocate another meta virtual space and add it to the list.
-bool VirtualSpaceList::grow_vs(size_t vs_word_size) {
+bool VirtualSpaceList::create_new_virtual_space(size_t vs_word_size) {
assert_lock_strong(SpaceManager::expand_lock());
- if (vs_word_size == 0) {
+
+ if (is_class()) {
+ assert(false, "We currently don't support more than one VirtualSpace for"
+ " the compressed class space. The initialization of the"
+ " CCS uses another code path and should not hit this path.");
return false;
}
+
+ if (vs_word_size == 0) {
+ assert(false, "vs_word_size should always be at least _reserve_alignment large.");
+ return false;
+ }
+
// Reserve the space
size_t vs_byte_size = vs_word_size * BytesPerWord;
- assert(vs_byte_size % os::vm_allocation_granularity() == 0, "Not aligned");
+ assert_is_size_aligned(vs_byte_size, Metaspace::reserve_alignment());
// Allocate the meta virtual space and initialize it.
VirtualSpaceNode* new_entry = new VirtualSpaceNode(vs_byte_size);
@@ -1103,7 +1177,8 @@
delete new_entry;
return false;
} else {
- assert(new_entry->reserved_words() == vs_word_size, "Must be");
+ assert(new_entry->reserved_words() == vs_word_size,
+ "Reserved memory size differs from requested memory size");
// ensure lock-free iteration sees fully initialized node
OrderAccess::storestore();
link_vs(new_entry);
@@ -1130,20 +1205,67 @@
}
}
-bool VirtualSpaceList::expand_by(VirtualSpaceNode* node, size_t word_size, bool pre_touch) {
+bool VirtualSpaceList::expand_node_by(VirtualSpaceNode* node,
+ size_t min_words,
+ size_t preferred_words) {
size_t before = node->committed_words();
- bool result = node->expand_by(word_size, pre_touch);
+ bool result = node->expand_by(min_words, preferred_words);
size_t after = node->committed_words();
// after and before can be the same if the memory was pre-committed.
- assert(after >= before, "Must be");
+ assert(after >= before, "Inconsistency");
inc_committed_words(after - before);
return result;
}
+bool VirtualSpaceList::expand_by(size_t min_words, size_t preferred_words) {
+ assert_is_size_aligned(min_words, Metaspace::commit_alignment_words());
+ assert_is_size_aligned(preferred_words, Metaspace::commit_alignment_words());
+ assert(min_words <= preferred_words, "Invalid arguments");
+
+ if (!MetaspaceGC::can_expand(min_words, this->is_class())) {
+ return false;
+ }
+
+ size_t allowed_expansion_words = MetaspaceGC::allowed_expansion();
+ if (allowed_expansion_words < min_words) {
+ return false;
+ }
+
+ size_t max_expansion_words = MIN2(preferred_words, allowed_expansion_words);
+
+ // Commit more memory from the the current virtual space.
+ bool vs_expanded = expand_node_by(current_virtual_space(),
+ min_words,
+ max_expansion_words);
+ if (vs_expanded) {
+ return true;
+ }
+
+ // Get another virtual space.
+ size_t grow_vs_words = MAX2((size_t)VirtualSpaceSize, preferred_words);
+ grow_vs_words = align_size_up(grow_vs_words, Metaspace::reserve_alignment_words());
+
+ if (create_new_virtual_space(grow_vs_words)) {
+ if (current_virtual_space()->is_pre_committed()) {
+ // The memory was pre-committed, so we are done here.
+ assert(min_words <= current_virtual_space()->committed_words(),
+ "The new VirtualSpace was pre-committed, so it"
+ "should be large enough to fit the alloc request.");
+ return true;
+ }
+
+ return expand_node_by(current_virtual_space(),
+ min_words,
+ max_expansion_words);
+ }
+
+ return false;
+}
+
Metachunk* VirtualSpaceList::get_new_chunk(size_t word_size,
size_t grow_chunks_by_words,
size_t medium_chunk_bunch) {
@@ -1151,63 +1273,27 @@
// Allocate a chunk out of the current virtual space.
Metachunk* next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
- if (next == NULL) {
- // Not enough room in current virtual space. Try to commit
- // more space.
- size_t expand_vs_by_words = MAX2(medium_chunk_bunch,
- grow_chunks_by_words);
- size_t page_size_words = os::vm_page_size() / BytesPerWord;
- size_t aligned_expand_vs_by_words = align_size_up(expand_vs_by_words,
- page_size_words);
- bool vs_expanded =
- expand_by(current_virtual_space(), aligned_expand_vs_by_words);
- if (!vs_expanded) {
- // Should the capacity of the metaspaces be expanded for
- // this allocation? If it's the virtual space for classes and is
- // being used for CompressedHeaders, don't allocate a new virtualspace.
- if (can_grow() && MetaspaceGC::should_expand(this, word_size)) {
- // Get another virtual space.
- size_t allocation_aligned_expand_words =
- align_size_up(aligned_expand_vs_by_words, os::vm_allocation_granularity() / BytesPerWord);
- size_t grow_vs_words =
- MAX2((size_t)VirtualSpaceSize, allocation_aligned_expand_words);
- if (grow_vs(grow_vs_words)) {
- // Got it. It's on the list now. Get a chunk from it.
- assert(current_virtual_space()->expanded_words() == 0,
- "New virtual space nodes should not have expanded");
-
- size_t grow_chunks_by_words_aligned = align_size_up(grow_chunks_by_words,
- page_size_words);
- // We probably want to expand by aligned_expand_vs_by_words here.
- expand_by(current_virtual_space(), grow_chunks_by_words_aligned);
- next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
- }
- } else {
- // Allocation will fail and induce a GC
- if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print_cr("VirtualSpaceList::get_new_chunk():"
- " Fail instead of expand the metaspace");
- }
- }
- } else {
- // The virtual space expanded, get a new chunk
- next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
- assert(next != NULL, "Just expanded, should succeed");
- }
+ if (next != NULL) {
+ return next;
}
- assert(next == NULL || (next->next() == NULL && next->prev() == NULL),
- "New chunk is still on some list");
- return next;
-}
-
-Metachunk* VirtualSpaceList::get_initialization_chunk(size_t chunk_word_size,
- size_t chunk_bunch) {
- // Get a chunk from the chunk freelist
- Metachunk* new_chunk = get_new_chunk(chunk_word_size,
- chunk_word_size,
- chunk_bunch);
- return new_chunk;
+ // The expand amount is currently only determined by the requested sizes
+ // and not how much committed memory is left in the current virtual space.
+
+ size_t min_word_size = align_size_up(grow_chunks_by_words, Metaspace::commit_alignment_words());
+ size_t preferred_word_size = align_size_up(medium_chunk_bunch, Metaspace::commit_alignment_words());
+ if (min_word_size >= preferred_word_size) {
+ // Can happen when humongous chunks are allocated.
+ preferred_word_size = min_word_size;
+ }
+
+ bool expanded = expand_by(min_word_size, preferred_word_size);
+ if (expanded) {
+ next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
+ assert(next != NULL, "The allocation was expected to succeed after the expansion");
+ }
+
+ return next;
}
void VirtualSpaceList::print_on(outputStream* st) const {
@@ -1256,96 +1342,96 @@
// Calculate the amount to increase the high water mark (HWM).
// Increase by a minimum amount (MinMetaspaceExpansion) so that
// another expansion is not requested too soon. If that is not
-// enough to satisfy the allocation (i.e. big enough for a word_size
-// allocation), increase by MaxMetaspaceExpansion. If that is still
-// not enough, expand by the size of the allocation (word_size) plus
-// some.
-size_t MetaspaceGC::delta_capacity_until_GC(size_t word_size) {
- size_t before_inc = MetaspaceGC::capacity_until_GC();
- size_t min_delta_words = MinMetaspaceExpansion / BytesPerWord;
- size_t max_delta_words = MaxMetaspaceExpansion / BytesPerWord;
- size_t page_size_words = os::vm_page_size() / BytesPerWord;
- size_t size_delta_words = align_size_up(word_size, page_size_words);
- size_t delta_words = MAX2(size_delta_words, min_delta_words);
- if (delta_words > min_delta_words) {
+// enough to satisfy the allocation, increase by MaxMetaspaceExpansion.
+// If that is still not enough, expand by the size of the allocation
+// plus some.
+size_t MetaspaceGC::delta_capacity_until_GC(size_t bytes) {
+ size_t min_delta = MinMetaspaceExpansion;
+ size_t max_delta = MaxMetaspaceExpansion;
+ size_t delta = align_size_up(bytes, Metaspace::commit_alignment());
+
+ if (delta <= min_delta) {
+ delta = min_delta;
+ } else if (delta <= max_delta) {
// Don't want to hit the high water mark on the next
// allocation so make the delta greater than just enough
// for this allocation.
- delta_words = MAX2(delta_words, max_delta_words);
- if (delta_words > max_delta_words) {
- // This allocation is large but the next ones are probably not
- // so increase by the minimum.
- delta_words = delta_words + min_delta_words;
- }
+ delta = max_delta;
+ } else {
+ // This allocation is large but the next ones are probably not
+ // so increase by the minimum.
+ delta = delta + min_delta;
}
- return delta_words;
+
+ assert_is_size_aligned(delta, Metaspace::commit_alignment());
+
+ return delta;
+}
+
+size_t MetaspaceGC::capacity_until_GC() {
+ size_t value = (size_t)OrderAccess::load_ptr_acquire(&_capacity_until_GC);
+ assert(value >= MetaspaceSize, "Not initialied properly?");
+ return value;
}
-bool MetaspaceGC::should_expand(VirtualSpaceList* vsl, size_t word_size) {
-
- // If the user wants a limit, impose one.
- // The reason for someone using this flag is to limit reserved space. So
- // for non-class virtual space, compare against virtual spaces that are reserved.
- // For class virtual space, we only compare against the committed space, not
- // reserved space, because this is a larger space prereserved for compressed
- // class pointers.
- if (!FLAG_IS_DEFAULT(MaxMetaspaceSize)) {
- size_t nonclass_allocated = MetaspaceAux::reserved_bytes(Metaspace::NonClassType);
- size_t class_allocated = MetaspaceAux::allocated_capacity_bytes(Metaspace::ClassType);
- size_t real_allocated = nonclass_allocated + class_allocated;
- if (real_allocated >= MaxMetaspaceSize) {
+size_t MetaspaceGC::inc_capacity_until_GC(size_t v) {
+ assert_is_size_aligned(v, Metaspace::commit_alignment());
+
+ return (size_t)Atomic::add_ptr(v, &_capacity_until_GC);
+}
+
+size_t MetaspaceGC::dec_capacity_until_GC(size_t v) {
+ assert_is_size_aligned(v, Metaspace::commit_alignment());
+
+ return (size_t)Atomic::add_ptr(-(intptr_t)v, &_capacity_until_GC);
+}
+
+bool MetaspaceGC::can_expand(size_t word_size, bool is_class) {
+ // Check if the compressed class space is full.
+ if (is_class && Metaspace::using_class_space()) {
+ size_t class_committed = MetaspaceAux::committed_bytes(Metaspace::ClassType);
+ if (class_committed + word_size * BytesPerWord > CompressedClassSpaceSize) {
return false;
}
}
- // Class virtual space should always be expanded. Call GC for the other
- // metadata virtual space.
- if (Metaspace::using_class_space() &&
- (vsl == Metaspace::class_space_list())) return true;
-
- // If this is part of an allocation after a GC, expand
- // unconditionally.
- if (MetaspaceGC::expand_after_GC()) {
- return true;
+ // Check if the user has imposed a limit on the metaspace memory.
+ size_t committed_bytes = MetaspaceAux::committed_bytes();
+ if (committed_bytes + word_size * BytesPerWord > MaxMetaspaceSize) {
+ return false;
}
-
- // If the capacity is below the minimum capacity, allow the
- // expansion. Also set the high-water-mark (capacity_until_GC)
- // to that minimum capacity so that a GC will not be induced
- // until that minimum capacity is exceeded.
- size_t committed_capacity_bytes = MetaspaceAux::allocated_capacity_bytes();
- size_t metaspace_size_bytes = MetaspaceSize;
- if (committed_capacity_bytes < metaspace_size_bytes ||
- capacity_until_GC() == 0) {
- set_capacity_until_GC(metaspace_size_bytes);
- return true;
- } else {
- if (committed_capacity_bytes < capacity_until_GC()) {
- return true;
- } else {
- if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print_cr(" allocation request size " SIZE_FORMAT
- " capacity_until_GC " SIZE_FORMAT
- " allocated_capacity_bytes " SIZE_FORMAT,
- word_size,
- capacity_until_GC(),
- MetaspaceAux::allocated_capacity_bytes());
- }
- return false;
- }
+ return true;
+}
+
+size_t MetaspaceGC::allowed_expansion() {
+ size_t committed_bytes = MetaspaceAux::committed_bytes();
+
+ size_t left_until_max = MaxMetaspaceSize - committed_bytes;
+
+ // Always grant expansion if we are initiating the JVM,
+ // or if the GC_locker is preventing GCs.
+ if (!is_init_completed() || GC_locker::is_active_and_needs_gc()) {
+ return left_until_max / BytesPerWord;
}
+
+ size_t capacity_until_gc = capacity_until_GC();
+
+ if (capacity_until_gc <= committed_bytes) {
+ return 0;
+ }
+
+ size_t left_until_GC = capacity_until_gc - committed_bytes;
+ size_t left_to_commit = MIN2(left_until_GC, left_until_max);
+
+ return left_to_commit / BytesPerWord;
}
-
-
void MetaspaceGC::compute_new_size() {
assert(_shrink_factor <= 100, "invalid shrink factor");
uint current_shrink_factor = _shrink_factor;
_shrink_factor = 0;
- // Until a faster way of calculating the "used" quantity is implemented,
- // use "capacity".
const size_t used_after_gc = MetaspaceAux::allocated_capacity_bytes();
const size_t capacity_until_GC = MetaspaceGC::capacity_until_GC();
@@ -1377,9 +1463,10 @@
// If we have less capacity below the metaspace HWM, then
// increment the HWM.
size_t expand_bytes = minimum_desired_capacity - capacity_until_GC;
+ expand_bytes = align_size_up(expand_bytes, Metaspace::commit_alignment());
// Don't expand unless it's significant
if (expand_bytes >= MinMetaspaceExpansion) {
- MetaspaceGC::set_capacity_until_GC(capacity_until_GC + expand_bytes);
+ MetaspaceGC::inc_capacity_until_GC(expand_bytes);
}
if (PrintGCDetails && Verbose) {
size_t new_capacity_until_GC = capacity_until_GC;
@@ -1436,6 +1523,9 @@
// on the third call, and 100% by the fourth call. But if we recompute
// size without shrinking, it goes back to 0%.
shrink_bytes = shrink_bytes / 100 * current_shrink_factor;
+
+ shrink_bytes = align_size_down(shrink_bytes, Metaspace::commit_alignment());
+
assert(shrink_bytes <= max_shrink_bytes,
err_msg("invalid shrink size " SIZE_FORMAT " not <= " SIZE_FORMAT,
shrink_bytes, max_shrink_bytes));
@@ -1467,7 +1557,7 @@
// Don't shrink unless it's significant
if (shrink_bytes >= MinMetaspaceExpansion &&
((capacity_until_GC - shrink_bytes) >= MetaspaceSize)) {
- MetaspaceGC::set_capacity_until_GC(capacity_until_GC - shrink_bytes);
+ MetaspaceGC::dec_capacity_until_GC(shrink_bytes);
}
}
@@ -1700,7 +1790,6 @@
assert(free_list != NULL, "Sanity check");
chunk = free_list->head();
- debug_only(Metachunk* debug_head = chunk;)
if (chunk == NULL) {
return NULL;
@@ -1709,9 +1798,6 @@
// Remove the chunk as the head of the list.
free_list->remove_chunk(chunk);
- // Chunk is being removed from the chunks free list.
- dec_free_chunks_total(chunk->capacity_word_size());
-
if (TraceMetadataChunkAllocation && Verbose) {
gclog_or_tty->print_cr("ChunkManager::free_chunks_get: free_list "
PTR_FORMAT " head " PTR_FORMAT " size " SIZE_FORMAT,
@@ -1722,21 +1808,22 @@
word_size,
FreeBlockDictionary<Metachunk>::atLeast);
- if (chunk != NULL) {
- if (TraceMetadataHumongousAllocation) {
- size_t waste = chunk->word_size() - word_size;
- gclog_or_tty->print_cr("Free list allocate humongous chunk size "
- SIZE_FORMAT " for requested size " SIZE_FORMAT
- " waste " SIZE_FORMAT,
- chunk->word_size(), word_size, waste);
- }
- // Chunk is being removed from the chunks free list.
- dec_free_chunks_total(chunk->capacity_word_size());
- } else {
+ if (chunk == NULL) {
return NULL;
}
+
+ if (TraceMetadataHumongousAllocation) {
+ size_t waste = chunk->word_size() - word_size;
+ gclog_or_tty->print_cr("Free list allocate humongous chunk size "
+ SIZE_FORMAT " for requested size " SIZE_FORMAT
+ " waste " SIZE_FORMAT,
+ chunk->word_size(), word_size, waste);
+ }
}
+ // Chunk is being removed from the chunks free list.
+ dec_free_chunks_total(chunk->capacity_word_size());
+
// Remove it from the links to this freelist
chunk->set_next(NULL);
chunk->set_prev(NULL);
@@ -1977,6 +2064,15 @@
return chunk_word_size;
}
+void SpaceManager::track_metaspace_memory_usage() {
+ if (is_init_completed()) {
+ if (is_class()) {
+ MemoryService::track_compressed_class_memory_usage();
+ }
+ MemoryService::track_metaspace_memory_usage();
+ }
+}
+
MetaWord* SpaceManager::grow_and_allocate(size_t word_size) {
assert(vs_list()->current_virtual_space() != NULL,
"Should have been set");
@@ -2002,15 +2098,24 @@
size_t grow_chunks_by_words = calc_chunk_size(word_size);
Metachunk* next = get_new_chunk(word_size, grow_chunks_by_words);
+ if (next != NULL) {
+ Metadebug::deallocate_chunk_a_lot(this, grow_chunks_by_words);
+ }
+
+ MetaWord* mem = NULL;
+
// If a chunk was available, add it to the in-use chunk list
// and do an allocation from it.
if (next != NULL) {
- Metadebug::deallocate_chunk_a_lot(this, grow_chunks_by_words);
// Add to this manager's list of chunks in use.
add_chunk(next, false);
- return next->allocate(word_size);
+ mem = next->allocate(word_size);
}
- return NULL;
+
+ // Track metaspace memory usage statistic.
+ track_metaspace_memory_usage();
+
+ return mem;
}
void SpaceManager::print_on(outputStream* st) const {
@@ -2366,6 +2471,7 @@
inc_used_metrics(word_size);
return current_chunk()->allocate(word_size); // caller handles null result
}
+
if (current_chunk() != NULL) {
result = current_chunk()->allocate(word_size);
}
@@ -2373,7 +2479,8 @@
if (result == NULL) {
result = grow_and_allocate(word_size);
}
- if (result != 0) {
+
+ if (result != NULL) {
inc_used_metrics(word_size);
assert(result != (MetaWord*) chunks_in_use(MediumIndex),
"Head of the list is being allocated");
@@ -2639,24 +2746,26 @@
void MetaspaceAux::print_on(outputStream* out) {
Metaspace::MetadataType nct = Metaspace::NonClassType;
- out->print_cr(" Metaspace total "
- SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
- " reserved " SIZE_FORMAT "K",
- allocated_capacity_bytes()/K, allocated_used_bytes()/K, reserved_bytes()/K);
-
- out->print_cr(" data space "
- SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
- " reserved " SIZE_FORMAT "K",
- allocated_capacity_bytes(nct)/K,
- allocated_used_bytes(nct)/K,
- reserved_bytes(nct)/K);
+ out->print_cr(" Metaspace "
+ "used " SIZE_FORMAT "K, "
+ "capacity " SIZE_FORMAT "K, "
+ "committed " SIZE_FORMAT "K, "
+ "reserved " SIZE_FORMAT "K",
+ allocated_used_bytes()/K,
+ allocated_capacity_bytes()/K,
+ committed_bytes()/K,
+ reserved_bytes()/K);
+
if (Metaspace::using_class_space()) {
Metaspace::MetadataType ct = Metaspace::ClassType;
out->print_cr(" class space "
- SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
- " reserved " SIZE_FORMAT "K",
+ "used " SIZE_FORMAT "K, "
+ "capacity " SIZE_FORMAT "K, "
+ "committed " SIZE_FORMAT "K, "
+ "reserved " SIZE_FORMAT "K",
+ allocated_used_bytes(ct)/K,
allocated_capacity_bytes(ct)/K,
- allocated_used_bytes(ct)/K,
+ committed_bytes(ct)/K,
reserved_bytes(ct)/K);
}
}
@@ -2808,6 +2917,9 @@
size_t Metaspace::_first_chunk_word_size = 0;
size_t Metaspace::_first_class_chunk_word_size = 0;
+size_t Metaspace::_commit_alignment = 0;
+size_t Metaspace::_reserve_alignment = 0;
+
Metaspace::Metaspace(Mutex* lock, MetaspaceType type) {
initialize(lock, type);
}
@@ -2869,21 +2981,30 @@
assert(UseCompressedClassPointers, "Only use with CompressedKlassPtrs");
assert(class_metaspace_size() < KlassEncodingMetaspaceMax,
"Metaspace size is too big");
+ assert_is_ptr_aligned(requested_addr, _reserve_alignment);
+ assert_is_ptr_aligned(cds_base, _reserve_alignment);
+ assert_is_size_aligned(class_metaspace_size(), _reserve_alignment);
+
+ // Don't use large pages for the class space.
+ bool large_pages = false;
ReservedSpace metaspace_rs = ReservedSpace(class_metaspace_size(),
- os::vm_allocation_granularity(),
- false, requested_addr, 0);
+ _reserve_alignment,
+ large_pages,
+ requested_addr, 0);
if (!metaspace_rs.is_reserved()) {
if (UseSharedSpaces) {
+ size_t increment = align_size_up(1*G, _reserve_alignment);
+
// Keep trying to allocate the metaspace, increasing the requested_addr
// by 1GB each time, until we reach an address that will no longer allow
// use of CDS with compressed klass pointers.
char *addr = requested_addr;
- while (!metaspace_rs.is_reserved() && (addr + 1*G > addr) &&
- can_use_cds_with_metaspace_addr(addr + 1*G, cds_base)) {
- addr = addr + 1*G;
+ while (!metaspace_rs.is_reserved() && (addr + increment > addr) &&
+ can_use_cds_with_metaspace_addr(addr + increment, cds_base)) {
+ addr = addr + increment;
metaspace_rs = ReservedSpace(class_metaspace_size(),
- os::vm_allocation_granularity(), false, addr, 0);
+ _reserve_alignment, large_pages, addr, 0);
}
}
@@ -2894,7 +3015,7 @@
// So, UseCompressedClassPointers cannot be turned off at this point.
if (!metaspace_rs.is_reserved()) {
metaspace_rs = ReservedSpace(class_metaspace_size(),
- os::vm_allocation_granularity(), false);
+ _reserve_alignment, large_pages);
if (!metaspace_rs.is_reserved()) {
vm_exit_during_initialization(err_msg("Could not allocate metaspace: %d bytes",
class_metaspace_size()));
@@ -2933,34 +3054,96 @@
assert(using_class_space(), "Must be using class space");
_class_space_list = new VirtualSpaceList(rs);
_chunk_manager_class = new ChunkManager(SpecializedChunk, ClassSmallChunk, ClassMediumChunk);
+
+ if (!_class_space_list->initialization_succeeded()) {
+ vm_exit_during_initialization("Failed to setup compressed class space virtual space list.");
+ }
}
#endif
+// Align down. If the aligning result in 0, return 'alignment'.
+static size_t restricted_align_down(size_t size, size_t alignment) {
+ return MAX2(alignment, align_size_down_(size, alignment));
+}
+
+void Metaspace::ergo_initialize() {
+ if (DumpSharedSpaces) {
+ // Using large pages when dumping the shared archive is currently not implemented.
+ FLAG_SET_ERGO(bool, UseLargePagesInMetaspace, false);
+ }
+
+ size_t page_size = os::vm_page_size();
+ if (UseLargePages && UseLargePagesInMetaspace) {
+ page_size = os::large_page_size();
+ }
+
+ _commit_alignment = page_size;
+ _reserve_alignment = MAX2(page_size, (size_t)os::vm_allocation_granularity());
+
+ // Do not use FLAG_SET_ERGO to update MaxMetaspaceSize, since this will
+ // override if MaxMetaspaceSize was set on the command line or not.
+ // This information is needed later to conform to the specification of the
+ // java.lang.management.MemoryUsage API.
+ //
+ // Ideally, we would be able to set the default value of MaxMetaspaceSize in
+ // globals.hpp to the aligned value, but this is not possible, since the
+ // alignment depends on other flags being parsed.
+ MaxMetaspaceSize = restricted_align_down(MaxMetaspaceSize, _reserve_alignment);
+
+ if (MetaspaceSize > MaxMetaspaceSize) {
+ MetaspaceSize = MaxMetaspaceSize;
+ }
+
+ MetaspaceSize = restricted_align_down(MetaspaceSize, _commit_alignment);
+
+ assert(MetaspaceSize <= MaxMetaspaceSize, "MetaspaceSize should be limited by MaxMetaspaceSize");
+
+ if (MetaspaceSize < 256*K) {
+ vm_exit_during_initialization("Too small initial Metaspace size");
+ }
+
+ MinMetaspaceExpansion = restricted_align_down(MinMetaspaceExpansion, _commit_alignment);
+ MaxMetaspaceExpansion = restricted_align_down(MaxMetaspaceExpansion, _commit_alignment);
+
+ CompressedClassSpaceSize = restricted_align_down(CompressedClassSpaceSize, _reserve_alignment);
+ set_class_metaspace_size(CompressedClassSpaceSize);
+}
+
void Metaspace::global_initialize() {
// Initialize the alignment for shared spaces.
int max_alignment = os::vm_page_size();
size_t cds_total = 0;
- set_class_metaspace_size(align_size_up(CompressedClassSpaceSize,
- os::vm_allocation_granularity()));
-
MetaspaceShared::set_max_alignment(max_alignment);
if (DumpSharedSpaces) {
- SharedReadOnlySize = align_size_up(SharedReadOnlySize, max_alignment);
+ SharedReadOnlySize = align_size_up(SharedReadOnlySize, max_alignment);
SharedReadWriteSize = align_size_up(SharedReadWriteSize, max_alignment);
- SharedMiscDataSize = align_size_up(SharedMiscDataSize, max_alignment);
- SharedMiscCodeSize = align_size_up(SharedMiscCodeSize, max_alignment);
+ SharedMiscDataSize = align_size_up(SharedMiscDataSize, max_alignment);
+ SharedMiscCodeSize = align_size_up(SharedMiscCodeSize, max_alignment);
// Initialize with the sum of the shared space sizes. The read-only
// and read write metaspace chunks will be allocated out of this and the
// remainder is the misc code and data chunks.
cds_total = FileMapInfo::shared_spaces_size();
+ cds_total = align_size_up(cds_total, _reserve_alignment);
_space_list = new VirtualSpaceList(cds_total/wordSize);
_chunk_manager_metadata = new ChunkManager(SpecializedChunk, SmallChunk, MediumChunk);
+ if (!_space_list->initialization_succeeded()) {
+ vm_exit_during_initialization("Unable to dump shared archive.", NULL);
+ }
+
#ifdef _LP64
+ if (cds_total + class_metaspace_size() > (uint64_t)max_juint) {
+ vm_exit_during_initialization("Unable to dump shared archive.",
+ err_msg("Size of archive (" SIZE_FORMAT ") + compressed class space ("
+ SIZE_FORMAT ") == total (" SIZE_FORMAT ") is larger than compressed "
+ "klass limit: " SIZE_FORMAT, cds_total, class_metaspace_size(),
+ cds_total + class_metaspace_size(), (size_t)max_juint));
+ }
+
// Set the compressed klass pointer base so that decoding of these pointers works
// properly when creating the shared archive.
assert(UseCompressedOops && UseCompressedClassPointers,
@@ -2971,9 +3154,6 @@
_space_list->current_virtual_space()->bottom());
}
- // Set the shift to zero.
- assert(class_metaspace_size() < (uint64_t)(max_juint) - cds_total,
- "CDS region is too large");
Universe::set_narrow_klass_shift(0);
#endif
@@ -2992,12 +3172,12 @@
// Map in spaces now also
if (mapinfo->initialize() && MetaspaceShared::map_shared_spaces(mapinfo)) {
FileMapInfo::set_current_info(mapinfo);
+ cds_total = FileMapInfo::shared_spaces_size();
+ cds_address = (address)mapinfo->region_base(0);
} else {
assert(!mapinfo->is_open() && !UseSharedSpaces,
"archive file not closed or shared spaces not disabled.");
}
- cds_total = FileMapInfo::shared_spaces_size();
- cds_address = (address)mapinfo->region_base(0);
}
#ifdef _LP64
@@ -3005,7 +3185,9 @@
// above the heap and above the CDS area (if it exists).
if (using_class_space()) {
if (UseSharedSpaces) {
- allocate_metaspace_compressed_klass_ptrs((char *)(cds_address + cds_total), cds_address);
+ char* cds_end = (char*)(cds_address + cds_total);
+ cds_end = (char *)align_ptr_up(cds_end, _reserve_alignment);
+ allocate_metaspace_compressed_klass_ptrs(cds_end, cds_address);
} else {
allocate_metaspace_compressed_klass_ptrs((char *)CompressedKlassPointersBase, 0);
}
@@ -3023,11 +3205,19 @@
_first_class_chunk_word_size = align_word_size_up(_first_class_chunk_word_size);
// Arbitrarily set the initial virtual space to a multiple
// of the boot class loader size.
- size_t word_size = VIRTUALSPACEMULTIPLIER * first_chunk_word_size();
+ size_t word_size = VIRTUALSPACEMULTIPLIER * _first_chunk_word_size;
+ word_size = align_size_up(word_size, Metaspace::reserve_alignment_words());
+
// Initialize the list of virtual spaces.
_space_list = new VirtualSpaceList(word_size);
_chunk_manager_metadata = new ChunkManager(SpecializedChunk, SmallChunk, MediumChunk);
+
+ if (!_space_list->initialization_succeeded()) {
+ vm_exit_during_initialization("Unable to setup metadata virtual space list.", NULL);
+ }
}
+
+ MetaspaceGC::initialize();
}
Metachunk* Metaspace::get_initialization_chunk(MetadataType mdtype,
@@ -3039,7 +3229,7 @@
return chunk;
}
- return get_space_list(mdtype)->get_initialization_chunk(chunk_word_size, chunk_bunch);
+ return get_space_list(mdtype)->get_new_chunk(chunk_word_size, chunk_word_size, chunk_bunch);
}
void Metaspace::initialize(Mutex* lock, MetaspaceType type) {
@@ -3112,19 +3302,18 @@
}
MetaWord* Metaspace::expand_and_allocate(size_t word_size, MetadataType mdtype) {
- MetaWord* result;
- MetaspaceGC::set_expand_after_GC(true);
- size_t before_inc = MetaspaceGC::capacity_until_GC();
- size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size) * BytesPerWord;
- MetaspaceGC::inc_capacity_until_GC(delta_bytes);
+ size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size * BytesPerWord);
+ assert(delta_bytes > 0, "Must be");
+
+ size_t after_inc = MetaspaceGC::inc_capacity_until_GC(delta_bytes);
+ size_t before_inc = after_inc - delta_bytes;
+
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT
- " to " SIZE_FORMAT, before_inc, MetaspaceGC::capacity_until_GC());
+ " to " SIZE_FORMAT, before_inc, after_inc);
}
- result = allocate(word_size, mdtype);
-
- return result;
+ return allocate(word_size, mdtype);
}
// Space allocated in the Metaspace. This may
@@ -3206,6 +3395,7 @@
}
}
+
Metablock* Metaspace::allocate(ClassLoaderData* loader_data, size_t word_size,
bool read_only, MetaspaceObj::Type type, TRAPS) {
if (HAS_PENDING_EXCEPTION) {
@@ -3213,20 +3403,16 @@
return NULL; // caller does a CHECK_NULL too
}
- MetadataType mdtype = (type == MetaspaceObj::ClassType) ? ClassType : NonClassType;
-
- // SSS: Should we align the allocations and make sure the sizes are aligned.
- MetaWord* result = NULL;
-
assert(loader_data != NULL, "Should never pass around a NULL loader_data. "
"ClassLoaderData::the_null_class_loader_data() should have been used.");
+
// Allocate in metaspaces without taking out a lock, because it deadlocks
// with the SymbolTable_lock. Dumping is single threaded for now. We'll have
// to revisit this for application class data sharing.
if (DumpSharedSpaces) {
assert(type > MetaspaceObj::UnknownType && type < MetaspaceObj::_number_of_types, "sanity");
Metaspace* space = read_only ? loader_data->ro_metaspace() : loader_data->rw_metaspace();
- result = space->allocate(word_size, NonClassType);
+ MetaWord* result = space->allocate(word_size, NonClassType);
if (result == NULL) {
report_out_of_shared_space(read_only ? SharedReadOnly : SharedReadWrite);
} else {
@@ -3235,40 +3421,62 @@
return Metablock::initialize(result, word_size);
}
- result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
+ MetadataType mdtype = (type == MetaspaceObj::ClassType) ? ClassType : NonClassType;
+
+ // Try to allocate metadata.
+ MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
+
+ if (result == NULL) {
+ // Allocation failed.
+ if (is_init_completed()) {
+ // Only start a GC if the bootstrapping has completed.
+
+ // Try to clean out some memory and retry.
+ result = Universe::heap()->collector_policy()->satisfy_failed_metadata_allocation(
+ loader_data, word_size, mdtype);
+ }
+ }
if (result == NULL) {
- // Try to clean out some memory and retry.
- result =
- Universe::heap()->collector_policy()->satisfy_failed_metadata_allocation(
- loader_data, word_size, mdtype);
-
- // If result is still null, we are out of memory.
- if (result == NULL) {
- if (Verbose && TraceMetadataChunkAllocation) {
- gclog_or_tty->print_cr("Metaspace allocation failed for size "
- SIZE_FORMAT, word_size);
- if (loader_data->metaspace_or_null() != NULL) loader_data->dump(gclog_or_tty);
- MetaspaceAux::dump(gclog_or_tty);
- }
- // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
- const char* space_string = is_class_space_allocation(mdtype) ? "Compressed class space" :
- "Metadata space";
- report_java_out_of_memory(space_string);
-
- if (JvmtiExport::should_post_resource_exhausted()) {
- JvmtiExport::post_resource_exhausted(
- JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
- space_string);
- }
- if (is_class_space_allocation(mdtype)) {
- THROW_OOP_0(Universe::out_of_memory_error_class_metaspace());
- } else {
- THROW_OOP_0(Universe::out_of_memory_error_metaspace());
- }
+ report_metadata_oome(loader_data, word_size, mdtype, THREAD);
+ // Will not reach here.
+ return NULL;
+ }
+
+ return Metablock::initialize(result, word_size);
+}
+
+void Metaspace::report_metadata_oome(ClassLoaderData* loader_data, size_t word_size, MetadataType mdtype, TRAPS) {
+ // If result is still null, we are out of memory.
+ if (Verbose && TraceMetadataChunkAllocation) {
+ gclog_or_tty->print_cr("Metaspace allocation failed for size "
+ SIZE_FORMAT, word_size);
+ if (loader_data->metaspace_or_null() != NULL) {
+ loader_data->dump(gclog_or_tty);
}
+ MetaspaceAux::dump(gclog_or_tty);
}
- return Metablock::initialize(result, word_size);
+
+ // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
+ const char* space_string = is_class_space_allocation(mdtype) ? "Compressed class space" :
+ "Metadata space";
+ report_java_out_of_memory(space_string);
+
+ if (JvmtiExport::should_post_resource_exhausted()) {
+ JvmtiExport::post_resource_exhausted(
+ JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
+ space_string);
+ }
+
+ if (!is_init_completed()) {
+ vm_exit_during_initialization("OutOfMemoryError", space_string);
+ }
+
+ if (is_class_space_allocation(mdtype)) {
+ THROW_OOP(Universe::out_of_memory_error_class_metaspace());
+ } else {
+ THROW_OOP(Universe::out_of_memory_error_metaspace());
+ }
}
void Metaspace::record_allocation(void* ptr, MetaspaceObj::Type type, size_t word_size) {
--- a/hotspot/src/share/vm/runtime/globals.hpp Fri Oct 11 15:04:53 2013 -0400
+++ b/hotspot/src/share/vm/runtime/globals.hpp Fri Oct 11 18:23:44 2013 -0700
@@ -481,21 +481,21 @@
#define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product) \
\
lp64_product(bool, UseCompressedOops, false, \
- "Use 32-bit object references in 64-bit VM " \
- "lp64_product means flag is always constant in 32 bit VM") \
+ "Use 32-bit object references in 64-bit VM. " \
+ "lp64_product means flag is always constant in 32 bit VM") \
\
lp64_product(bool, UseCompressedClassPointers, false, \
- "Use 32-bit class pointers in 64-bit VM " \
- "lp64_product means flag is always constant in 32 bit VM") \
+ "Use 32-bit class pointers in 64-bit VM. " \
+ "lp64_product means flag is always constant in 32 bit VM") \
\
notproduct(bool, CheckCompressedOops, true, \
- "generate checks in encoding/decoding code in debug VM") \
+ "Generate checks in encoding/decoding code in debug VM") \
\
product_pd(uintx, HeapBaseMinAddress, \
- "OS specific low limit for heap base address") \
+ "OS specific low limit for heap base address") \
\
diagnostic(bool, PrintCompressedOopsMode, false, \
- "Print compressed oops base address and encoding mode") \
+ "Print compressed oops base address and encoding mode") \
\
lp64_product(intx, ObjectAlignmentInBytes, 8, \
"Default object alignment in bytes, 8 is minimum") \
@@ -517,7 +517,7 @@
"Use lwsync instruction if true, else use slower sync") \
\
develop(bool, CleanChunkPoolAsync, falseInEmbedded, \
- "Whether to clean the chunk pool asynchronously") \
+ "Clean the chunk pool asynchronously") \
\
/* Temporary: See 6948537 */ \
experimental(bool, UseMemSetInBOT, true, \
@@ -527,10 +527,12 @@
"Enable normal processing of flags relating to field diagnostics")\
\
experimental(bool, UnlockExperimentalVMOptions, false, \
- "Enable normal processing of flags relating to experimental features")\
+ "Enable normal processing of flags relating to experimental " \
+ "features") \
\
product(bool, JavaMonitorsInStackTrace, true, \
- "Print info. about Java monitor locks when the stacks are dumped")\
+ "Print information about Java monitor locks when the stacks are" \
+ "dumped") \
\
product_pd(bool, UseLargePages, \
"Use large page memory") \
@@ -541,8 +543,12 @@
develop(bool, LargePagesIndividualAllocationInjectError, false, \
"Fail large pages individual allocation") \
\
+ product(bool, UseLargePagesInMetaspace, false, \
+ "Use large page memory in metaspace. " \
+ "Only used if UseLargePages is enabled.") \
+ \
develop(bool, TracePageSizes, false, \
- "Trace page size selection and usage.") \
+ "Trace page size selection and usage") \
\
product(bool, UseNUMA, false, \
"Use NUMA if available") \
@@ -557,12 +563,12 @@
"Force NUMA optimizations on single-node/UMA systems") \
\
product(uintx, NUMAChunkResizeWeight, 20, \
- "Percentage (0-100) used to weigh the current sample when " \
+ "Percentage (0-100) used to weigh the current sample when " \
"computing exponentially decaying average for " \
"AdaptiveNUMAChunkSizing") \
\
product(uintx, NUMASpaceResizeRate, 1*G, \
- "Do not reallocate more that this amount per collection") \
+ "Do not reallocate more than this amount per collection") \
\
product(bool, UseAdaptiveNUMAChunkSizing, true, \
"Enable adaptive chunk sizing for NUMA") \
@@ -579,17 +585,17 @@
product(intx, UseSSE, 99, \
"Highest supported SSE instructions set on x86/x64") \
\
- product(bool, UseAES, false, \
+ product(bool, UseAES, false, \
"Control whether AES instructions can be used on x86/x64") \
\
product(uintx, LargePageSizeInBytes, 0, \
- "Large page size (0 to let VM choose the page size") \
+ "Large page size (0 to let VM choose the page size)") \
\
product(uintx, LargePageHeapSizeThreshold, 128*M, \
- "Use large pages if max heap is at least this big") \
+ "Use large pages if maximum heap is at least this big") \
\
product(bool, ForceTimeHighResolution, false, \
- "Using high time resolution(For Win32 only)") \
+ "Using high time resolution (for Win32 only)") \
\
develop(bool, TraceItables, false, \
"Trace initialization and use of itables") \
@@ -605,10 +611,10 @@
\
develop(bool, TraceLongCompiles, false, \
"Print out every time compilation is longer than " \
- "a given threashold") \
+ "a given threshold") \
\
develop(bool, SafepointALot, false, \
- "Generates a lot of safepoints. Works with " \
+ "Generate a lot of safepoints. This works with " \
"GuaranteedSafepointInterval") \
\
product_pd(bool, BackgroundCompilation, \
@@ -616,13 +622,13 @@
"compilation") \
\
product(bool, PrintVMQWaitTime, false, \
- "Prints out the waiting time in VM operation queue") \
+ "Print out the waiting time in VM operation queue") \
\
develop(bool, NoYieldsInMicrolock, false, \
"Disable yields in microlock") \
\
develop(bool, TraceOopMapGeneration, false, \
- "Shows oopmap generation") \
+ "Show OopMapGeneration") \
\
product(bool, MethodFlushing, true, \
"Reclamation of zombie and not-entrant methods") \
@@ -631,10 +637,11 @@
"Verify stack of each thread when it is entering a runtime call") \
\
diagnostic(bool, ForceUnreachable, false, \
- "Make all non code cache addresses to be unreachable with forcing use of 64bit literal fixups") \
+ "Make all non code cache addresses to be unreachable by " \
+ "forcing use of 64bit literal fixups") \
\
notproduct(bool, StressDerivedPointers, false, \
- "Force scavenge when a derived pointers is detected on stack " \
+ "Force scavenge when a derived pointer is detected on stack " \
"after rtm call") \
\
develop(bool, TraceDerivedPointers, false, \
@@ -653,86 +660,86 @@
"Use Inline Caches for virtual calls ") \
\
develop(bool, InlineArrayCopy, true, \
- "inline arraycopy native that is known to be part of " \
+ "Inline arraycopy native that is known to be part of " \
"base library DLL") \
\
develop(bool, InlineObjectHash, true, \
- "inline Object::hashCode() native that is known to be part " \
+ "Inline Object::hashCode() native that is known to be part " \
"of base library DLL") \
\
develop(bool, InlineNatives, true, \
- "inline natives that are known to be part of base library DLL") \
+ "Inline natives that are known to be part of base library DLL") \
\
develop(bool, InlineMathNatives, true, \
- "inline SinD, CosD, etc.") \
+ "Inline SinD, CosD, etc.") \
\
develop(bool, InlineClassNatives, true, \
- "inline Class.isInstance, etc") \
+ "Inline Class.isInstance, etc") \
\
develop(bool, InlineThreadNatives, true, \
- "inline Thread.currentThread, etc") \
+ "Inline Thread.currentThread, etc") \
\
develop(bool, InlineUnsafeOps, true, \
- "inline memory ops (native methods) from sun.misc.Unsafe") \
+ "Inline memory ops (native methods) from sun.misc.Unsafe") \
\
product(bool, CriticalJNINatives, true, \
- "check for critical JNI entry points") \
+ "Check for critical JNI entry points") \
\
notproduct(bool, StressCriticalJNINatives, false, \
- "Exercise register saving code in critical natives") \
+ "Exercise register saving code in critical natives") \
\
product(bool, UseSSE42Intrinsics, false, \
"SSE4.2 versions of intrinsics") \
\
product(bool, UseAESIntrinsics, false, \
- "use intrinsics for AES versions of crypto") \
+ "Use intrinsics for AES versions of crypto") \
\
product(bool, UseCRC32Intrinsics, false, \
"use intrinsics for java.util.zip.CRC32") \
\
develop(bool, TraceCallFixup, false, \
- "traces all call fixups") \
+ "Trace all call fixups") \
\
develop(bool, DeoptimizeALot, false, \
- "deoptimize at every exit from the runtime system") \
+ "Deoptimize at every exit from the runtime system") \
\
notproduct(ccstrlist, DeoptimizeOnlyAt, "", \
- "a comma separated list of bcis to deoptimize at") \
+ "A comma separated list of bcis to deoptimize at") \
\
product(bool, DeoptimizeRandom, false, \
- "deoptimize random frames on random exit from the runtime system")\
+ "Deoptimize random frames on random exit from the runtime system")\
\
notproduct(bool, ZombieALot, false, \
- "creates zombies (non-entrant) at exit from the runt. system") \
+ "Create zombies (non-entrant) at exit from the runtime system") \
\
product(bool, UnlinkSymbolsALot, false, \
- "unlink unreferenced symbols from the symbol table at safepoints")\
+ "Unlink unreferenced symbols from the symbol table at safepoints")\
\
notproduct(bool, WalkStackALot, false, \
- "trace stack (no print) at every exit from the runtime system") \
+ "Trace stack (no print) at every exit from the runtime system") \
\
product(bool, Debugging, false, \
- "set when executing debug methods in debug.ccp " \
+ "Set when executing debug methods in debug.cpp " \
"(to prevent triggering assertions)") \
\
notproduct(bool, StrictSafepointChecks, trueInDebug, \
"Enable strict checks that safepoints cannot happen for threads " \
- "that used No_Safepoint_Verifier") \
+ "that use No_Safepoint_Verifier") \
\
notproduct(bool, VerifyLastFrame, false, \
"Verify oops on last frame on entry to VM") \
\
develop(bool, TraceHandleAllocation, false, \
- "Prints out warnings when suspicious many handles are allocated") \
+ "Print out warnings when suspiciously many handles are allocated")\
\
product(bool, UseCompilerSafepoints, true, \
"Stop at safepoints in compiled code") \
\
product(bool, FailOverToOldVerifier, true, \
- "fail over to old verifier when split verifier fails") \
+ "Fail over to old verifier when split verifier fails") \
\
develop(bool, ShowSafepointMsgs, false, \
- "Show msg. about safepoint synch.") \
+ "Show message about safepoint synchronization") \
\
product(bool, SafepointTimeout, false, \
"Time out and warn or fail after SafepointTimeoutDelay " \
@@ -756,19 +763,19 @@
"Trace external suspend wait failures") \
\
product(bool, MaxFDLimit, true, \
- "Bump the number of file descriptors to max in solaris.") \
+ "Bump the number of file descriptors to maximum in Solaris") \
\
diagnostic(bool, LogEvents, true, \
- "Enable the various ring buffer event logs") \
+ "Enable the various ring buffer event logs") \
\
diagnostic(uintx, LogEventsBufferEntries, 10, \
- "Enable the various ring buffer event logs") \
+ "Number of ring buffer event logs") \
\
product(bool, BytecodeVerificationRemote, true, \
- "Enables the Java bytecode verifier for remote classes") \
+ "Enable the Java bytecode verifier for remote classes") \
\
product(bool, BytecodeVerificationLocal, false, \
- "Enables the Java bytecode verifier for local classes") \
+ "Enable the Java bytecode verifier for local classes") \
\
develop(bool, ForceFloatExceptions, trueInDebug, \
"Force exceptions on FP stack under/overflow") \
@@ -780,7 +787,7 @@
"Trace java language assertions") \
\
notproduct(bool, CheckAssertionStatusDirectives, false, \
- "temporary - see javaClasses.cpp") \
+ "Temporary - see javaClasses.cpp") \
\
notproduct(bool, PrintMallocFree, false, \
"Trace calls to C heap malloc/free allocation") \
@@ -799,16 +806,16 @@
"entering the VM") \
\
notproduct(bool, CheckOopishValues, false, \
- "Warn if value contains oop ( requires ZapDeadLocals)") \
+ "Warn if value contains oop (requires ZapDeadLocals)") \
\
develop(bool, UseMallocOnly, false, \
- "use only malloc/free for allocation (no resource area/arena)") \
+ "Use only malloc/free for allocation (no resource area/arena)") \
\
develop(bool, PrintMalloc, false, \
- "print all malloc/free calls") \
+ "Print all malloc/free calls") \
\
develop(bool, PrintMallocStatistics, false, \
- "print malloc/free statistics") \
+ "Print malloc/free statistics") \
\
develop(bool, ZapResourceArea, trueInDebug, \
"Zap freed resource/arena space with 0xABABABAB") \
@@ -820,7 +827,7 @@
"Zap freed JNI handle space with 0xFEFEFEFE") \
\
notproduct(bool, ZapStackSegments, trueInDebug, \
- "Zap allocated/freed Stack segments with 0xFADFADED") \
+ "Zap allocated/freed stack segments with 0xFADFADED") \
\
develop(bool, ZapUnusedHeapArea, trueInDebug, \
"Zap unused heap space with 0xBAADBABE") \
@@ -835,7 +842,7 @@
"Zap filler objects with 0xDEAFBABE") \
\
develop(bool, PrintVMMessages, true, \
- "Print vm messages on console") \
+ "Print VM messages on console") \
\
product(bool, PrintGCApplicationConcurrentTime, false, \
"Print the time the application has been running") \
@@ -844,21 +851,21 @@
"Print the time the application has been stopped") \
\
diagnostic(bool, VerboseVerification, false, \
- "Display detailed verification details") \
+ "Display detailed verification details") \
\
notproduct(uintx, ErrorHandlerTest, 0, \
- "If > 0, provokes an error after VM initialization; the value" \
- "determines which error to provoke. See test_error_handler()" \
+ "If > 0, provokes an error after VM initialization; the value " \
+ "determines which error to provoke. See test_error_handler() " \
"in debug.cpp.") \
\
develop(bool, Verbose, false, \
- "Prints additional debugging information from other modes") \
+ "Print additional debugging information from other modes") \
\
develop(bool, PrintMiscellaneous, false, \
- "Prints uncategorized debugging information (requires +Verbose)") \
+ "Print uncategorized debugging information (requires +Verbose)") \
\
develop(bool, WizardMode, false, \
- "Prints much more debugging information") \
+ "Print much more debugging information") \
\
product(bool, ShowMessageBoxOnError, false, \
"Keep process alive on VM fatal error") \
@@ -870,7 +877,7 @@
"Let VM fatal error propagate to the OS (ie. WER on Windows)") \
\
product(bool, SuppressFatalErrorMessage, false, \
- "Do NO Fatal Error report [Avoid deadlock]") \
+ "Report NO fatal error message (avoid deadlock)") \
\
product(ccstrlist, OnError, "", \
"Run user-defined commands on fatal error; see VMError.cpp " \
@@ -880,17 +887,17 @@
"Run user-defined commands on first java.lang.OutOfMemoryError") \
\
manageable(bool, HeapDumpBeforeFullGC, false, \
- "Dump heap to file before any major stop-world GC") \
+ "Dump heap to file before any major stop-the-world GC") \
\
manageable(bool, HeapDumpAfterFullGC, false, \
- "Dump heap to file after any major stop-world GC") \
+ "Dump heap to file after any major stop-the-world GC") \
\
manageable(bool, HeapDumpOnOutOfMemoryError, false, \
"Dump heap to file when java.lang.OutOfMemoryError is thrown") \
\
manageable(ccstr, HeapDumpPath, NULL, \
- "When HeapDumpOnOutOfMemoryError is on, the path (filename or" \
- "directory) of the dump file (defaults to java_pid<pid>.hprof" \
+ "When HeapDumpOnOutOfMemoryError is on, the path (filename or " \
+ "directory) of the dump file (defaults to java_pid<pid>.hprof " \
"in the working directory)") \
\
develop(uintx, SegmentedHeapDumpThreshold, 2*G, \
@@ -904,10 +911,10 @@
"Execute breakpoint upon encountering VM warning") \
\
develop(bool, TraceVMOperation, false, \
- "Trace vm operations") \
+ "Trace VM operations") \
\
develop(bool, UseFakeTimers, false, \
- "Tells whether the VM should use system time or a fake timer") \
+ "Tell whether the VM should use system time or a fake timer") \
\
product(ccstr, NativeMemoryTracking, "off", \
"Native memory tracking options") \
@@ -917,7 +924,7 @@
\
diagnostic(bool, AutoShutdownNMT, true, \
"Automatically shutdown native memory tracking under stress " \
- "situation. When set to false, native memory tracking tries to " \
+ "situations. When set to false, native memory tracking tries to " \
"stay alive at the expense of JVM performance") \
\
diagnostic(bool, LogCompilation, false, \
@@ -927,12 +934,12 @@
"Print compilations") \
\
diagnostic(bool, TraceNMethodInstalls, false, \
- "Trace nmethod intallation") \
+ "Trace nmethod installation") \
\
diagnostic(intx, ScavengeRootsInCode, 2, \
- "0: do not allow scavengable oops in the code cache; " \
- "1: allow scavenging from the code cache; " \
- "2: emit as many constants as the compiler can see") \
+ "0: do not allow scavengable oops in the code cache; " \
+ "1: allow scavenging from the code cache; " \
+ "2: emit as many constants as the compiler can see") \
\
product(bool, AlwaysRestoreFPU, false, \
"Restore the FPU control word after every JNI call (expensive)") \
@@ -953,7 +960,7 @@
"Print assembly code (using external disassembler.so)") \
\
diagnostic(ccstr, PrintAssemblyOptions, NULL, \
- "Options string passed to disassembler.so") \
+ "Print options string passed to disassembler.so") \
\
diagnostic(bool, PrintNMethods, false, \
"Print assembly code for nmethods when generated") \
@@ -974,20 +981,21 @@
"Print exception handler tables for all nmethods when generated") \
\
develop(bool, StressCompiledExceptionHandlers, false, \
- "Exercise compiled exception handlers") \
+ "Exercise compiled exception handlers") \
\
develop(bool, InterceptOSException, false, \
- "Starts debugger when an implicit OS (e.g., NULL) " \
+ "Start debugger when an implicit OS (e.g. NULL) " \
"exception happens") \
\
product(bool, PrintCodeCache, false, \
"Print the code cache memory usage when exiting") \
\
develop(bool, PrintCodeCache2, false, \
- "Print detailed usage info on the code cache when exiting") \
+ "Print detailed usage information on the code cache when exiting")\
\
product(bool, PrintCodeCacheOnCompilation, false, \
- "Print the code cache memory usage each time a method is compiled") \
+ "Print the code cache memory usage each time a method is " \
+ "compiled") \
\
diagnostic(bool, PrintStubCode, false, \
"Print generated stub code") \
@@ -999,40 +1007,40 @@
"Omit backtraces for some 'hot' exceptions in optimized code") \
\
product(bool, ProfilerPrintByteCodeStatistics, false, \
- "Prints byte code statictics when dumping profiler output") \
+ "Print bytecode statistics when dumping profiler output") \
\
product(bool, ProfilerRecordPC, false, \
- "Collects tick for each 16 byte interval of compiled code") \
+ "Collect ticks for each 16 byte interval of compiled code") \
\
product(bool, ProfileVM, false, \
- "Profiles ticks that fall within VM (either in the VM Thread " \
+ "Profile ticks that fall within VM (either in the VM Thread " \
"or VM code called through stubs)") \
\
product(bool, ProfileIntervals, false, \
- "Prints profiles for each interval (see ProfileIntervalsTicks)") \
+ "Print profiles for each interval (see ProfileIntervalsTicks)") \
\
notproduct(bool, ProfilerCheckIntervals, false, \
- "Collect and print info on spacing of profiler ticks") \
+ "Collect and print information on spacing of profiler ticks") \
\
develop(bool, PrintJVMWarnings, false, \
- "Prints warnings for unimplemented JVM functions") \
+ "Print warnings for unimplemented JVM functions") \
\
product(bool, PrintWarnings, true, \
- "Prints JVM warnings to output stream") \
+ "Print JVM warnings to output stream") \
\
notproduct(uintx, WarnOnStalledSpinLock, 0, \
- "Prints warnings for stalled SpinLocks") \
+ "Print warnings for stalled SpinLocks") \
\
product(bool, RegisterFinalizersAtInit, true, \
"Register finalizable objects at end of Object.<init> or " \
"after allocation") \
\
develop(bool, RegisterReferences, true, \
- "Tells whether the VM should register soft/weak/final/phantom " \
+ "Tell whether the VM should register soft/weak/final/phantom " \
"references") \
\
develop(bool, IgnoreRewrites, false, \
- "Supress rewrites of bytecodes in the oopmap generator. " \
+ "Suppress rewrites of bytecodes in the oopmap generator. " \
"This is unsafe!") \
\
develop(bool, PrintCodeCacheExtension, false, \
@@ -1042,8 +1050,7 @@
"Enable the security JVM functions") \
\
develop(bool, ProtectionDomainVerification, true, \
- "Verifies protection domain before resolution in system " \
- "dictionary") \
+ "Verify protection domain before resolution in system dictionary")\
\
product(bool, ClassUnloading, true, \
"Do unloading of classes") \
@@ -1056,14 +1063,14 @@
"Write memory usage profiling to log file") \
\
notproduct(bool, PrintSystemDictionaryAtExit, false, \
- "Prints the system dictionary at exit") \
+ "Print the system dictionary at exit") \
\
experimental(intx, PredictedLoadedClassCount, 0, \
- "Experimental: Tune loaded class cache starting size.") \
+ "Experimental: Tune loaded class cache starting size") \
\
diagnostic(bool, UnsyncloadClass, false, \
"Unstable: VM calls loadClass unsynchronized. Custom " \
- "class loader must call VM synchronized for findClass " \
+ "class loader must call VM synchronized for findClass " \
"and defineClass.") \
\
product(bool, AlwaysLockClassLoader, false, \
@@ -1079,22 +1086,22 @@
"Call loadClassInternal() rather than loadClass()") \
\
product_pd(bool, DontYieldALot, \
- "Throw away obvious excess yield calls (for SOLARIS only)") \
+ "Throw away obvious excess yield calls (for Solaris only)") \
\
product_pd(bool, ConvertSleepToYield, \
- "Converts sleep(0) to thread yield " \
- "(may be off for SOLARIS to improve GUI)") \
+ "Convert sleep(0) to thread yield " \
+ "(may be off for Solaris to improve GUI)") \
\
product(bool, ConvertYieldToSleep, false, \
- "Converts yield to a sleep of MinSleepInterval to simulate Win32 "\
- "behavior (SOLARIS only)") \
+ "Convert yield to a sleep of MinSleepInterval to simulate Win32 " \
+ "behavior (Solaris only)") \
\
product(bool, UseBoundThreads, true, \
- "Bind user level threads to kernel threads (for SOLARIS only)") \
+ "Bind user level threads to kernel threads (for Solaris only)") \
\
develop(bool, UseDetachedThreads, true, \
"Use detached threads that are recycled upon termination " \
- "(for SOLARIS only)") \
+ "(for Solaris only)") \
\
product(bool, UseLWPSynchronization, true, \
"Use LWP-based instead of libthread-based synchronization " \
@@ -1104,41 +1111,43 @@
"(Unstable) Various monitor synchronization tunables") \
\
product(intx, EmitSync, 0, \
- "(Unsafe,Unstable) " \
- " Controls emission of inline sync fast-path code") \
+ "(Unsafe, Unstable) " \
+ "Control emission of inline sync fast-path code") \
\
product(intx, MonitorBound, 0, "Bound Monitor population") \
\
product(bool, MonitorInUseLists, false, "Track Monitors for Deflation") \
\
- product(intx, SyncFlags, 0, "(Unsafe,Unstable) Experimental Sync flags" ) \
- \
- product(intx, SyncVerbose, 0, "(Unstable)" ) \
- \
- product(intx, ClearFPUAtPark, 0, "(Unsafe,Unstable)" ) \
+ product(intx, SyncFlags, 0, "(Unsafe, Unstable) Experimental Sync flags") \
+ \
+ product(intx, SyncVerbose, 0, "(Unstable)") \
+ \
+ product(intx, ClearFPUAtPark, 0, "(Unsafe, Unstable)") \
\
product(intx, hashCode, 5, \
- "(Unstable) select hashCode generation algorithm" ) \
+ "(Unstable) select hashCode generation algorithm") \
\
product(intx, WorkAroundNPTLTimedWaitHang, 1, \
- "(Unstable, Linux-specific)" \
- " avoid NPTL-FUTEX hang pthread_cond_timedwait" ) \
+ "(Unstable, Linux-specific) " \
+ "avoid NPTL-FUTEX hang pthread_cond_timedwait") \
\
product(bool, FilterSpuriousWakeups, true, \
"Prevent spurious or premature wakeups from object.wait " \
"(Solaris only)") \
\
- product(intx, NativeMonitorTimeout, -1, "(Unstable)" ) \
- product(intx, NativeMonitorFlags, 0, "(Unstable)" ) \
- product(intx, NativeMonitorSpinLimit, 20, "(Unstable)" ) \
+ product(intx, NativeMonitorTimeout, -1, "(Unstable)") \
+ \
+ product(intx, NativeMonitorFlags, 0, "(Unstable)") \
+ \
+ product(intx, NativeMonitorSpinLimit, 20, "(Unstable)") \
\
develop(bool, UsePthreads, false, \
"Use pthread-based instead of libthread-based synchronization " \
"(SPARC only)") \
\
product(bool, AdjustConcurrency, false, \
- "call thr_setconcurrency at thread create time to avoid " \
- "LWP starvation on MP systems (For Solaris Only)") \
+ "Call thr_setconcurrency at thread creation time to avoid " \
+ "LWP starvation on MP systems (for Solaris Only)") \
\
product(bool, ReduceSignalUsage, false, \
"Reduce the use of OS signals in Java and/or the VM") \
@@ -1147,13 +1156,14 @@
"Share vtable stubs (smaller code but worse branch prediction") \
\
develop(bool, LoadLineNumberTables, true, \
- "Tells whether the class file parser loads line number tables") \
+ "Tell whether the class file parser loads line number tables") \
\
develop(bool, LoadLocalVariableTables, true, \
- "Tells whether the class file parser loads local variable tables")\
+ "Tell whether the class file parser loads local variable tables") \
\
develop(bool, LoadLocalVariableTypeTables, true, \
- "Tells whether the class file parser loads local variable type tables")\
+ "Tell whether the class file parser loads local variable type" \
+ "tables") \
\
product(bool, AllowUserSignalHandlers, false, \
"Do not complain if the application installs signal handlers " \
@@ -1184,10 +1194,12 @@
\
product(bool, EagerXrunInit, false, \
"Eagerly initialize -Xrun libraries; allows startup profiling, " \
- " but not all -Xrun libraries may support the state of the VM at this time") \
+ "but not all -Xrun libraries may support the state of the VM " \
+ "at this time") \
\
product(bool, PreserveAllAnnotations, false, \
- "Preserve RuntimeInvisibleAnnotations as well as RuntimeVisibleAnnotations") \
+ "Preserve RuntimeInvisibleAnnotations as well " \
+ "as RuntimeVisibleAnnotations") \
\
develop(uintx, PreallocatedOutOfMemoryErrorCount, 4, \
"Number of OutOfMemoryErrors preallocated with backtrace") \
@@ -1262,7 +1274,7 @@
"Trace level for JVMTI RedefineClasses") \
\
develop(bool, StressMethodComparator, false, \
- "run the MethodComparator on all loaded methods") \
+ "Run the MethodComparator on all loaded methods") \
\
/* change to false by default sometime after Mustang */ \
product(bool, VerifyMergedCPBytecodes, true, \
@@ -1296,7 +1308,7 @@
"Trace dependencies") \
\
develop(bool, VerifyDependencies, trueInDebug, \
- "Exercise and verify the compilation dependency mechanism") \
+ "Exercise and verify the compilation dependency mechanism") \
\
develop(bool, TraceNewOopMapGeneration, false, \
"Trace OopMapGeneration") \
@@ -1314,7 +1326,7 @@
"Trace monitor matching failures during OopMapGeneration") \
\
develop(bool, TraceOopMapRewrites, false, \
- "Trace rewritting of method oops during oop map generation") \
+ "Trace rewriting of method oops during oop map generation") \
\
develop(bool, TraceSafepoint, false, \
"Trace safepoint operations") \
@@ -1332,10 +1344,10 @@
"Trace setup time") \
\
develop(bool, TraceProtectionDomainVerification, false, \
- "Trace protection domain verifcation") \
+ "Trace protection domain verification") \
\
develop(bool, TraceClearedExceptions, false, \
- "Prints when an exception is forcibly cleared") \
+ "Print when an exception is forcibly cleared") \
\
product(bool, TraceClassResolution, false, \
"Trace all constant pool resolutions (for debugging)") \
@@ -1349,7 +1361,7 @@
/* gc */ \
\
product(bool, UseSerialGC, false, \
- "Use the serial garbage collector") \
+ "Use the Serial garbage collector") \
\
product(bool, UseG1GC, false, \
"Use the Garbage-First garbage collector") \
@@ -1368,16 +1380,16 @@
"The collection count for the first maximum compaction") \
\
product(bool, UseMaximumCompactionOnSystemGC, true, \
- "In the Parallel Old garbage collector maximum compaction for " \
- "a system GC") \
+ "Use maximum compaction in the Parallel Old garbage collector " \
+ "for a system GC") \
\
product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
- "The mean used by the par compact dead wood" \
- "limiter (a number between 0-100).") \
+ "The mean used by the parallel compact dead wood " \
+ "limiter (a number between 0-100)") \
\
product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
- "The standard deviation used by the par compact dead wood" \
- "limiter (a number between 0-100).") \
+ "The standard deviation used by the parallel compact dead wood " \
+ "limiter (a number between 0-100)") \
\
product(uintx, ParallelGCThreads, 0, \
"Number of parallel threads parallel gc will use") \
@@ -1387,7 +1399,7 @@
"parallel gc will use") \
\
diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
- "Force dynamic selection of the number of" \
+ "Force dynamic selection of the number of " \
"parallel threads parallel gc will use to aid debugging") \
\
product(uintx, HeapSizePerGCThread, ScaleForWordSize(64*M), \
@@ -1398,7 +1410,7 @@
"Trace the dynamic GC thread usage") \
\
develop(bool, ParallelOldGCSplitALot, false, \
- "Provoke splitting (copying data from a young gen space to" \
+ "Provoke splitting (copying data from a young gen space to " \
"multiple destination spaces)") \
\
develop(uintx, ParallelOldGCSplitInterval, 3, \
@@ -1408,19 +1420,19 @@
"Number of threads concurrent gc will use") \
\
product(uintx, YoungPLABSize, 4096, \
- "Size of young gen promotion labs (in HeapWords)") \
+ "Size of young gen promotion LAB's (in HeapWords)") \
\
product(uintx, OldPLABSize, 1024, \
- "Size of old gen promotion labs (in HeapWords)") \
+ "Size of old gen promotion LAB's (in HeapWords)") \
\
product(uintx, GCTaskTimeStampEntries, 200, \
"Number of time stamp entries per gc worker thread") \
\
product(bool, AlwaysTenure, false, \
- "Always tenure objects in eden. (ParallelGC only)") \
+ "Always tenure objects in eden (ParallelGC only)") \
\
product(bool, NeverTenure, false, \
- "Never tenure objects in eden, May tenure on overflow " \
+ "Never tenure objects in eden, may tenure on overflow " \
"(ParallelGC only)") \
\
product(bool, ScavengeBeforeFullGC, true, \
@@ -1428,14 +1440,14 @@
"used with UseParallelGC") \
\
develop(bool, ScavengeWithObjectsInToSpace, false, \
- "Allow scavenges to occur when to_space contains objects.") \
+ "Allow scavenges to occur when to-space contains objects") \
\
product(bool, UseConcMarkSweepGC, false, \
"Use Concurrent Mark-Sweep GC in the old generation") \
\
product(bool, ExplicitGCInvokesConcurrent, false, \
- "A System.gc() request invokes a concurrent collection;" \
- " (effective only when UseConcMarkSweepGC)") \
+ "A System.gc() request invokes a concurrent collection; " \
+ "(effective only when UseConcMarkSweepGC)") \
\
product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false, \
"A System.gc() request invokes a concurrent collection and " \
@@ -1443,19 +1455,19 @@
"(effective only when UseConcMarkSweepGC)") \
\
product(bool, GCLockerInvokesConcurrent, false, \
- "The exit of a JNI CS necessitating a scavenge also" \
- " kicks off a bkgrd concurrent collection") \
+ "The exit of a JNI critical section necessitating a scavenge, " \
+ "also kicks off a background concurrent collection") \
\
product(uintx, GCLockerEdenExpansionPercent, 5, \
- "How much the GC can expand the eden by while the GC locker " \
+ "How much the GC can expand the eden by while the GC locker " \
"is active (as a percentage)") \
\
diagnostic(intx, GCLockerRetryAllocationCount, 2, \
- "Number of times to retry allocations when" \
- " blocked by the GC locker") \
+ "Number of times to retry allocations when " \
+ "blocked by the GC locker") \
\
develop(bool, UseCMSAdaptiveFreeLists, true, \
- "Use Adaptive Free Lists in the CMS generation") \
+ "Use adaptive free lists in the CMS generation") \
\
develop(bool, UseAsyncConcMarkSweepGC, true, \
"Use Asynchronous Concurrent Mark-Sweep GC in the old generation")\
@@ -1470,44 +1482,46 @@
"Use passing of collection from background to foreground") \
\
product(bool, UseParNewGC, false, \
- "Use parallel threads in the new generation.") \
+ "Use parallel threads in the new generation") \
\
product(bool, ParallelGCVerbose, false, \
- "Verbose output for parallel GC.") \
+ "Verbose output for parallel gc") \
\
product(uintx, ParallelGCBufferWastePct, 10, \
- "Wasted fraction of parallel allocation buffer.") \
+ "Wasted fraction of parallel allocation buffer") \
\
diagnostic(bool, ParallelGCRetainPLAB, false, \
- "Retain parallel allocation buffers across scavenges; " \
- " -- disabled because this currently conflicts with " \
- " parallel card scanning under certain conditions ") \
+ "Retain parallel allocation buffers across scavenges; " \
+ "it is disabled because this currently conflicts with " \
+ "parallel card scanning under certain conditions.") \
\
product(uintx, TargetPLABWastePct, 10, \
"Target wasted space in last buffer as percent of overall " \
"allocation") \
\
product(uintx, PLABWeight, 75, \
- "Percentage (0-100) used to weight the current sample when" \
- "computing exponentially decaying average for ResizePLAB.") \
+ "Percentage (0-100) used to weigh the current sample when " \
+ "computing exponentially decaying average for ResizePLAB") \
\
product(bool, ResizePLAB, true, \
- "Dynamically resize (survivor space) promotion labs") \
+ "Dynamically resize (survivor space) promotion LAB's") \
\
product(bool, PrintPLAB, false, \
- "Print (survivor space) promotion labs sizing decisions") \
+ "Print (survivor space) promotion LAB's sizing decisions") \
\
product(intx, ParGCArrayScanChunk, 50, \
- "Scan a subset and push remainder, if array is bigger than this") \
+ "Scan a subset of object array and push remainder, if array is " \
+ "bigger than this") \
\
product(bool, ParGCUseLocalOverflow, false, \
"Instead of a global overflow list, use local overflow stacks") \
\
product(bool, ParGCTrimOverflow, true, \
- "Eagerly trim the local overflow lists (when ParGCUseLocalOverflow") \
+ "Eagerly trim the local overflow lists " \
+ "(when ParGCUseLocalOverflow)") \
\
notproduct(bool, ParGCWorkQueueOverflowALot, false, \
- "Whether we should simulate work queue overflow in ParNew") \
+ "Simulate work queue overflow in ParNew") \
\
notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
"An `interval' counter that determines how frequently " \
@@ -1525,43 +1539,46 @@
"during card table scanning") \
\
product(uintx, CMSParPromoteBlocksToClaim, 16, \
- "Number of blocks to attempt to claim when refilling CMS LAB for "\
- "parallel GC.") \
+ "Number of blocks to attempt to claim when refilling CMS LAB's " \
+ "for parallel GC") \
\
product(uintx, OldPLABWeight, 50, \
- "Percentage (0-100) used to weight the current sample when" \
- "computing exponentially decaying average for resizing CMSParPromoteBlocksToClaim.") \
+ "Percentage (0-100) used to weight the current sample when " \
+ "computing exponentially decaying average for resizing " \
+ "CMSParPromoteBlocksToClaim") \
\
product(bool, ResizeOldPLAB, true, \
- "Dynamically resize (old gen) promotion labs") \
+ "Dynamically resize (old gen) promotion LAB's") \
\
product(bool, PrintOldPLAB, false, \
- "Print (old gen) promotion labs sizing decisions") \
+ "Print (old gen) promotion LAB's sizing decisions") \
\
product(uintx, CMSOldPLABMin, 16, \
- "Min size of CMS gen promotion lab caches per worker per blksize")\
+ "Minimum size of CMS gen promotion LAB caches per worker " \
+ "per block size") \
\
product(uintx, CMSOldPLABMax, 1024, \
- "Max size of CMS gen promotion lab caches per worker per blksize")\
+ "Maximum size of CMS gen promotion LAB caches per worker " \
+ "per block size") \
\
product(uintx, CMSOldPLABNumRefills, 4, \
- "Nominal number of refills of CMS gen promotion lab cache" \
- " per worker per block size") \
+ "Nominal number of refills of CMS gen promotion LAB cache " \
+ "per worker per block size") \
\
product(bool, CMSOldPLABResizeQuicker, false, \
- "Whether to react on-the-fly during a scavenge to a sudden" \
- " change in block demand rate") \
+ "React on-the-fly during a scavenge to a sudden " \
+ "change in block demand rate") \
\
product(uintx, CMSOldPLABToleranceFactor, 4, \
- "The tolerance of the phase-change detector for on-the-fly" \
- " PLAB resizing during a scavenge") \
+ "The tolerance of the phase-change detector for on-the-fly " \
+ "PLAB resizing during a scavenge") \
\
product(uintx, CMSOldPLABReactivityFactor, 2, \
- "The gain in the feedback loop for on-the-fly PLAB resizing" \
- " during a scavenge") \
+ "The gain in the feedback loop for on-the-fly PLAB resizing " \
+ "during a scavenge") \
\
product(bool, AlwaysPreTouch, false, \
- "It forces all freshly committed pages to be pre-touched.") \
+ "Force all freshly committed pages to be pre-touched") \
\
product_pd(uintx, CMSYoungGenPerWorker, \
"The maximum size of young gen chosen by default per GC worker " \
@@ -1571,64 +1588,67 @@
"Whether CMS GC should operate in \"incremental\" mode") \
\
product(uintx, CMSIncrementalDutyCycle, 10, \
- "CMS incremental mode duty cycle (a percentage, 0-100). If" \
- "CMSIncrementalPacing is enabled, then this is just the initial" \
- "value") \
+ "Percentage (0-100) of CMS incremental mode duty cycle. If " \
+ "CMSIncrementalPacing is enabled, then this is just the initial " \
+ "value.") \
\
product(bool, CMSIncrementalPacing, true, \
"Whether the CMS incremental mode duty cycle should be " \
"automatically adjusted") \
\
product(uintx, CMSIncrementalDutyCycleMin, 0, \
- "Lower bound on the duty cycle when CMSIncrementalPacing is " \
- "enabled (a percentage, 0-100)") \
+ "Minimum percentage (0-100) of the CMS incremental duty cycle " \
+ "used when CMSIncrementalPacing is enabled") \
\
product(uintx, CMSIncrementalSafetyFactor, 10, \
"Percentage (0-100) used to add conservatism when computing the " \
"duty cycle") \
\
product(uintx, CMSIncrementalOffset, 0, \
- "Percentage (0-100) by which the CMS incremental mode duty cycle" \
- " is shifted to the right within the period between young GCs") \
+ "Percentage (0-100) by which the CMS incremental mode duty cycle "\
+ "is shifted to the right within the period between young GCs") \
\
product(uintx, CMSExpAvgFactor, 50, \
- "Percentage (0-100) used to weight the current sample when" \
- "computing exponential averages for CMS statistics.") \
+ "Percentage (0-100) used to weigh the current sample when " \
+ "computing exponential averages for CMS statistics") \
\
product(uintx, CMS_FLSWeight, 75, \
- "Percentage (0-100) used to weight the current sample when" \
- "computing exponentially decating averages for CMS FLS statistics.") \
+ "Percentage (0-100) used to weigh the current sample when " \
+ "computing exponentially decaying averages for CMS FLS " \
+ "statistics") \
\
product(uintx, CMS_FLSPadding, 1, \
- "The multiple of deviation from mean to use for buffering" \
- "against volatility in free list demand.") \
+ "The multiple of deviation from mean to use for buffering " \
+ "against volatility in free list demand") \
\
product(uintx, FLSCoalescePolicy, 2, \
- "CMS: Aggression level for coalescing, increasing from 0 to 4") \
+ "CMS: aggressiveness level for coalescing, increasing " \
+ "from 0 to 4") \
\
product(bool, FLSAlwaysCoalesceLarge, false, \
- "CMS: Larger free blocks are always available for coalescing") \
+ "CMS: larger free blocks are always available for coalescing") \
\
product(double, FLSLargestBlockCoalesceProximity, 0.99, \
- "CMS: the smaller the percentage the greater the coalition force")\
+ "CMS: the smaller the percentage the greater the coalescing " \
+ "force") \
\
product(double, CMSSmallCoalSurplusPercent, 1.05, \
- "CMS: the factor by which to inflate estimated demand of small" \
- " block sizes to prevent coalescing with an adjoining block") \
+ "CMS: the factor by which to inflate estimated demand of small " \
+ "block sizes to prevent coalescing with an adjoining block") \
\
product(double, CMSLargeCoalSurplusPercent, 0.95, \
- "CMS: the factor by which to inflate estimated demand of large" \
- " block sizes to prevent coalescing with an adjoining block") \
+ "CMS: the factor by which to inflate estimated demand of large " \
+ "block sizes to prevent coalescing with an adjoining block") \
\
product(double, CMSSmallSplitSurplusPercent, 1.10, \
- "CMS: the factor by which to inflate estimated demand of small" \
- " block sizes to prevent splitting to supply demand for smaller" \
- " blocks") \
+ "CMS: the factor by which to inflate estimated demand of small " \
+ "block sizes to prevent splitting to supply demand for smaller " \
+ "blocks") \
\
product(double, CMSLargeSplitSurplusPercent, 1.00, \
- "CMS: the factor by which to inflate estimated demand of large" \
- " block sizes to prevent splitting to supply demand for smaller" \
- " blocks") \
+ "CMS: the factor by which to inflate estimated demand of large " \
+ "block sizes to prevent splitting to supply demand for smaller " \
+ "blocks") \
\
product(bool, CMSExtrapolateSweep, false, \
"CMS: cushion for block demand during sweep") \
@@ -1640,11 +1660,11 @@
\
product(uintx, CMS_SweepPadding, 1, \
"The multiple of deviation from mean to use for buffering " \
- "against volatility in inter-sweep duration.") \
+ "against volatility in inter-sweep duration") \
\
product(uintx, CMS_SweepTimerThresholdMillis, 10, \
"Skip block flux-rate sampling for an epoch unless inter-sweep " \
- "duration exceeds this threhold in milliseconds") \
+ "duration exceeds this threshold in milliseconds") \
\
develop(bool, CMSTraceIncrementalMode, false, \
"Trace CMS incremental mode") \
@@ -1659,14 +1679,15 @@
"Whether class unloading enabled when using CMS GC") \
\
product(uintx, CMSClassUnloadingMaxInterval, 0, \
- "When CMS class unloading is enabled, the maximum CMS cycle count"\
- " for which classes may not be unloaded") \
+ "When CMS class unloading is enabled, the maximum CMS cycle " \
+ "count for which classes may not be unloaded") \
\
product(bool, CMSCompactWhenClearAllSoftRefs, true, \
- "Compact when asked to collect CMS gen with clear_all_soft_refs") \
+ "Compact when asked to collect CMS gen with " \
+ "clear_all_soft_refs()") \
\
product(bool, UseCMSCompactAtFullCollection, true, \
- "Use mark sweep compact at full collections") \
+ "Use Mark-Sweep-Compact algorithm at full collections") \
\
product(uintx, CMSFullGCsBeforeCompaction, 0, \
"Number of CMS full collection done before compaction if > 0") \
@@ -1688,38 +1709,37 @@
"Warn in case of excessive CMS looping") \
\
develop(bool, CMSOverflowEarlyRestoration, false, \
- "Whether preserved marks should be restored early") \
+ "Restore preserved marks early") \
\
product(uintx, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
"Size of marking stack") \
\
product(uintx, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
- "Max size of marking stack") \
+ "Maximum size of marking stack") \
\
notproduct(bool, CMSMarkStackOverflowALot, false, \
- "Whether we should simulate frequent marking stack / work queue" \
- " overflow") \
+ "Simulate frequent marking stack / work queue overflow") \
\
notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
- "An `interval' counter that determines how frequently" \
- " we simulate overflow; a smaller number increases frequency") \
+ "An \"interval\" counter that determines how frequently " \
+ "to simulate overflow; a smaller number increases frequency") \
\
product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
- "(Temporary, subject to experimentation)" \
+ "(Temporary, subject to experimentation) " \
"Maximum number of abortable preclean iterations, if > 0") \
\
product(intx, CMSMaxAbortablePrecleanTime, 5000, \
- "(Temporary, subject to experimentation)" \
- "Maximum time in abortable preclean in ms") \
+ "(Temporary, subject to experimentation) " \
+ "Maximum time in abortable preclean (in milliseconds)") \
\
product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
- "(Temporary, subject to experimentation)" \
+ "(Temporary, subject to experimentation) " \
"Nominal minimum work per abortable preclean iteration") \
\
manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
- "(Temporary, subject to experimentation)" \
- " Time that we sleep between iterations when not given" \
- " enough work per iteration") \
+ "(Temporary, subject to experimentation) " \
+ "Time that we sleep between iterations when not given " \
+ "enough work per iteration") \
\
product(uintx, CMSRescanMultiple, 32, \
"Size (in cards) of CMS parallel rescan task") \
@@ -1737,23 +1757,24 @@
"Whether parallel remark enabled (only if ParNewGC)") \
\
product(bool, CMSParallelSurvivorRemarkEnabled, true, \
- "Whether parallel remark of survivor space" \
- " enabled (effective only if CMSParallelRemarkEnabled)") \
+ "Whether parallel remark of survivor space " \
+ "enabled (effective only if CMSParallelRemarkEnabled)") \
\
product(bool, CMSPLABRecordAlways, true, \
- "Whether to always record survivor space PLAB bdries" \
- " (effective only if CMSParallelSurvivorRemarkEnabled)") \
+ "Always record survivor space PLAB boundaries (effective only " \
+ "if CMSParallelSurvivorRemarkEnabled)") \
\
product(bool, CMSEdenChunksRecordAlways, true, \
- "Whether to always record eden chunks used for " \
- "the parallel initial mark or remark of eden" ) \
+ "Always record eden chunks used for the parallel initial mark " \
+ "or remark of eden") \
\
product(bool, CMSPrintEdenSurvivorChunks, false, \
"Print the eden and the survivor chunks used for the parallel " \
"initial mark or remark of the eden/survivor spaces") \
\
product(bool, CMSConcurrentMTEnabled, true, \
- "Whether multi-threaded concurrent work enabled (if ParNewGC)") \
+ "Whether multi-threaded concurrent work enabled " \
+ "(effective only if ParNewGC)") \
\
product(bool, CMSPrecleaningEnabled, true, \
"Whether concurrent precleaning enabled") \
@@ -1762,12 +1783,12 @@
"Maximum number of precleaning iteration passes") \
\
product(uintx, CMSPrecleanNumerator, 2, \
- "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" \
- " ratio") \
+ "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
+ "ratio") \
\
product(uintx, CMSPrecleanDenominator, 3, \
- "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" \
- " ratio") \
+ "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
+ "ratio") \
\
product(bool, CMSPrecleanRefLists1, true, \
"Preclean ref lists during (initial) preclean phase") \
@@ -1782,7 +1803,7 @@
"Preclean survivors during abortable preclean phase") \
\
product(uintx, CMSPrecleanThreshold, 1000, \
- "Don't re-iterate if #dirty cards less than this") \
+ "Do not iterate again if number of dirty cards is less than this")\
\
product(bool, CMSCleanOnEnter, true, \
"Clean-on-enter optimization for reducing number of dirty cards") \
@@ -1791,14 +1812,16 @@
"Choose variant (1,2) of verification following remark") \
\
product(uintx, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
- "If Eden used is below this value, don't try to schedule remark") \
+ "If Eden size is below this, do not try to schedule remark") \
\
product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
- "The Eden occupancy % at which to try and schedule remark pause") \
+ "The Eden occupancy percentage (0-100) at which " \
+ "to try and schedule remark pause") \
\
product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
- "Start sampling Eden top at least before yg occupancy reaches" \
- " 1/<ratio> of the size at which we plan to schedule remark") \
+ "Start sampling eden top at least before young gen " \
+ "occupancy reaches 1/<ratio> of the size at which " \
+ "we plan to schedule remark") \
\
product(uintx, CMSSamplingGrain, 16*K, \
"The minimum distance between eden samples for CMS (see above)") \
@@ -1820,27 +1843,27 @@
"should start a collection cycle") \
\
product(bool, CMSYield, true, \
- "Yield between steps of concurrent mark & sweep") \
+ "Yield between steps of CMS") \
\
product(uintx, CMSBitMapYieldQuantum, 10*M, \
- "Bitmap operations should process at most this many bits" \
+ "Bitmap operations should process at most this many bits " \
"between yields") \
\
product(bool, CMSDumpAtPromotionFailure, false, \
"Dump useful information about the state of the CMS old " \
- " generation upon a promotion failure.") \
+ "generation upon a promotion failure") \
\
product(bool, CMSPrintChunksInDump, false, \
"In a dump enabled by CMSDumpAtPromotionFailure, include " \
- " more detailed information about the free chunks.") \
+ "more detailed information about the free chunks") \
\
product(bool, CMSPrintObjectsInDump, false, \
"In a dump enabled by CMSDumpAtPromotionFailure, include " \
- " more detailed information about the allocated objects.") \
+ "more detailed information about the allocated objects") \
\
diagnostic(bool, FLSVerifyAllHeapReferences, false, \
- "Verify that all refs across the FLS boundary " \
- " are to valid objects") \
+ "Verify that all references across the FLS boundary " \
+ "are to valid objects") \
\
diagnostic(bool, FLSVerifyLists, false, \
"Do lots of (expensive) FreeListSpace verification") \
@@ -1852,17 +1875,18 @@
"Do lots of (expensive) FLS dictionary verification") \
\
develop(bool, VerifyBlockOffsetArray, false, \
- "Do (expensive!) block offset array verification") \
+ "Do (expensive) block offset array verification") \
\
diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
- "Maintain _unallocated_block in BlockOffsetArray" \
- " (currently applicable only to CMS collector)") \
+ "Maintain _unallocated_block in BlockOffsetArray " \
+ "(currently applicable only to CMS collector)") \
\
develop(bool, TraceCMSState, false, \
"Trace the state of the CMS collection") \
\
product(intx, RefDiscoveryPolicy, 0, \
- "Whether reference-based(0) or referent-based(1)") \
+ "Select type of reference discovery policy: " \
+ "reference-based(0) or referent-based(1)") \
\
product(bool, ParallelRefProcEnabled, false, \
"Enable parallel reference processing whenever possible") \
@@ -1890,7 +1914,7 @@
"denotes 'do constant GC cycles'.") \
\
product(bool, UseCMSInitiatingOccupancyOnly, false, \
- "Only use occupancy as a crierion for starting a CMS collection") \
+ "Only use occupancy as a criterion for starting a CMS collection")\
\
product(uintx, CMSIsTooFullPercentage, 98, \
"An absolute ceiling above which CMS will always consider the " \
@@ -1902,7 +1926,7 @@
\
notproduct(bool, CMSVerifyReturnedBytes, false, \
"Check that all the garbage collected was returned to the " \
- "free lists.") \
+ "free lists") \
\
notproduct(bool, ScavengeALot, false, \
"Force scavenge at every Nth exit from the runtime system " \
@@ -1917,16 +1941,16 @@
\
product(bool, PrintPromotionFailure, false, \
"Print additional diagnostic information following " \
- " promotion failure") \
+ "promotion failure") \
\
notproduct(bool, PromotionFailureALot, false, \
"Use promotion failure handling on every youngest generation " \
"collection") \
\
develop(uintx, PromotionFailureALotCount, 1000, \
- "Number of promotion failures occurring at ParGCAllocBuffer" \
+ "Number of promotion failures occurring at ParGCAllocBuffer " \
"refill attempts (ParNew) or promotion attempts " \
- "(other young collectors) ") \
+ "(other young collectors)") \
\
develop(uintx, PromotionFailureALotInterval, 5, \
"Total collections between promotion failures alot") \
@@ -1945,7 +1969,7 @@
"Ratio of hard spins to calls to yield") \
\
develop(uintx, ObjArrayMarkingStride, 512, \
- "Number of ObjArray elements to push onto the marking stack" \
+ "Number of object array elements to push onto the marking stack " \
"before pushing a continuation entry") \
\
develop(bool, MetadataAllocationFailALot, false, \
@@ -1953,7 +1977,7 @@
"MetadataAllocationFailALotInterval") \
\
develop(uintx, MetadataAllocationFailALotInterval, 1000, \
- "metadata allocation failure alot interval") \
+ "Metadata allocation failure a lot interval") \
\
develop(bool, MetaDataDeallocateALot, false, \
"Deallocation bunches of metadata at intervals controlled by " \
@@ -1972,7 +1996,7 @@
"Trace virtual space metadata allocations") \
\
notproduct(bool, ExecuteInternalVMTests, false, \
- "Enable execution of internal VM tests.") \
+ "Enable execution of internal VM tests") \
\
notproduct(bool, VerboseInternalVMTests, false, \
"Turn on logging for internal VM tests.") \
@@ -1980,7 +2004,7 @@
product_pd(bool, UseTLAB, "Use thread-local object allocation") \
\
product_pd(bool, ResizeTLAB, \
- "Dynamically resize tlab size for threads") \
+ "Dynamically resize TLAB size for threads") \
\
product(bool, ZeroTLAB, false, \
"Zero out the newly created TLAB") \
@@ -1992,7 +2016,8 @@
"Print various TLAB related information") \
\
product(bool, TLABStats, true, \
- "Print various TLAB related information") \
+ "Provide more detailed and expensive TLAB statistics " \
+ "(with PrintTLAB)") \
\
EMBEDDED_ONLY(product(bool, LowMemoryProtection, true, \
"Enable LowMemoryProtection")) \
@@ -2026,14 +2051,14 @@
"Fraction (1/n) of real memory used for initial heap size") \
\
develop(uintx, MaxVirtMemFraction, 2, \
- "Maximum fraction (1/n) of virtual memory used for ergonomically" \
+ "Maximum fraction (1/n) of virtual memory used for ergonomically "\
"determining maximum heap size") \
\
product(bool, UseAutoGCSelectPolicy, false, \
"Use automatic collection selection policy") \
\
product(uintx, AutoGCSelectPauseMillis, 5000, \
- "Automatic GC selection pause threshhold in ms") \
+ "Automatic GC selection pause threshold in milliseconds") \
\
product(bool, UseAdaptiveSizePolicy, true, \
"Use adaptive generation sizing policies") \
@@ -2048,7 +2073,7 @@
"Use adaptive young-old sizing policies at major collections") \
\
product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
- "Use statistics from System.GC for adaptive size policy") \
+ "Include statistics from System.gc() for adaptive size policy") \
\
product(bool, UseAdaptiveGCBoundary, false, \
"Allow young-old boundary to move") \
@@ -2060,16 +2085,16 @@
"Resize the virtual spaces of the young or old generations") \
\
product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
- "Policy for changeing generation size for throughput goals") \
+ "Policy for changing generation size for throughput goals") \
\
product(uintx, AdaptiveSizePausePolicy, 0, \
"Policy for changing generation size for pause goals") \
\
develop(bool, PSAdjustTenuredGenForMinorPause, false, \
- "Adjust tenured generation to achive a minor pause goal") \
+ "Adjust tenured generation to achieve a minor pause goal") \
\
develop(bool, PSAdjustYoungGenForMajorPause, false, \
- "Adjust young generation to achive a major pause goal") \
+ "Adjust young generation to achieve a major pause goal") \
\
product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
"Number of steps where heuristics is used before data is used") \
@@ -2124,14 +2149,15 @@
"Decay factor to TenuredGenerationSizeIncrement") \
\
product(uintx, MaxGCPauseMillis, max_uintx, \
- "Adaptive size policy maximum GC pause time goal in msec, " \
- "or (G1 Only) the max. GC time per MMU time slice") \
+ "Adaptive size policy maximum GC pause time goal in millisecond, "\
+ "or (G1 Only) the maximum GC time per MMU time slice") \
\
product(uintx, GCPauseIntervalMillis, 0, \
"Time slice for MMU specification") \
\
product(uintx, MaxGCMinorPauseMillis, max_uintx, \
- "Adaptive size policy maximum GC minor pause time goal in msec") \
+ "Adaptive size policy maximum GC minor pause time goal " \
+ "in millisecond") \
\
product(uintx, GCTimeRatio, 99, \
"Adaptive size policy application time to GC time ratio") \
@@ -2159,8 +2185,8 @@
"before an OutOfMemory error is thrown") \
\
product(uintx, GCTimeLimit, 98, \
- "Limit of proportion of time spent in GC before an OutOfMemory" \
- "error is thrown (used with GCHeapFreeLimit)") \
+ "Limit of the proportion of time spent in GC before " \
+ "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
\
product(uintx, GCHeapFreeLimit, 2, \
"Minimum percentage of free space after a full GC before an " \
@@ -2182,7 +2208,7 @@
"How many fields ahead to prefetch in oop scan (<= 0 means off)") \
\
diagnostic(bool, VerifySilently, false, \
- "Don't print print the verification progress") \
+ "Do not print the verification progress") \
\
diagnostic(bool, VerifyDuringStartup, false, \
"Verify memory system before executing any Java code " \
@@ -2205,7 +2231,7 @@
\
diagnostic(bool, DeferInitialCardMark, false, \
"When +ReduceInitialCardMarks, explicitly defer any that " \
- "may arise from new_pre_store_barrier") \
+ "may arise from new_pre_store_barrier") \
\
diagnostic(bool, VerifyRememberedSets, false, \
"Verify GC remembered sets") \
@@ -2214,10 +2240,10 @@
"Verify GC object start array if verify before/after") \
\
product(bool, DisableExplicitGC, false, \
- "Tells whether calling System.gc() does a full GC") \
+ "Ignore calls to System.gc()") \
\
notproduct(bool, CheckMemoryInitialization, false, \
- "Checks memory initialization") \
+ "Check memory initialization") \
\
product(bool, CollectGen0First, false, \
"Collect youngest generation before each full GC") \
@@ -2238,44 +2264,45 @@
"Stride through processors when distributing processes") \
\
product(uintx, CMSCoordinatorYieldSleepCount, 10, \
- "number of times the coordinator GC thread will sleep while " \
+ "Number of times the coordinator GC thread will sleep while " \
"yielding before giving up and resuming GC") \
\
product(uintx, CMSYieldSleepCount, 0, \
- "number of times a GC thread (minus the coordinator) " \
+ "Number of times a GC thread (minus the coordinator) " \
"will sleep while yielding before giving up and resuming GC") \
\
/* gc tracing */ \
manageable(bool, PrintGC, false, \
- "Print message at garbage collect") \
+ "Print message at garbage collection") \
\
manageable(bool, PrintGCDetails, false, \
- "Print more details at garbage collect") \
+ "Print more details at garbage collection") \
\
manageable(bool, PrintGCDateStamps, false, \
- "Print date stamps at garbage collect") \
+ "Print date stamps at garbage collection") \
\
manageable(bool, PrintGCTimeStamps, false, \
- "Print timestamps at garbage collect") \
+ "Print timestamps at garbage collection") \
\
product(bool, PrintGCTaskTimeStamps, false, \
"Print timestamps for individual gc worker thread tasks") \
\
develop(intx, ConcGCYieldTimeout, 0, \
- "If non-zero, assert that GC threads yield within this # of ms.") \
+ "If non-zero, assert that GC threads yield within this " \
+ "number of milliseconds") \
\
notproduct(bool, TraceMarkSweep, false, \
"Trace mark sweep") \
\
product(bool, PrintReferenceGC, false, \
"Print times spent handling reference objects during GC " \
- " (enabled only when PrintGCDetails)") \
+ "(enabled only when PrintGCDetails)") \
\
develop(bool, TraceReferenceGC, false, \
"Trace handling of soft/weak/final/phantom references") \
\
develop(bool, TraceFinalizerRegistration, false, \
- "Trace registration of final references") \
+ "Trace registration of final references") \
\
notproduct(bool, TraceScavenge, false, \
"Trace scavenge") \
@@ -2312,7 +2339,7 @@
"Print heap layout before and after each GC") \
\
product_rw(bool, PrintHeapAtGCExtended, false, \
- "Prints extended information about the layout of the heap " \
+ "Print extended information about the layout of the heap " \
"when -XX:+PrintHeapAtGC is set") \
\
product(bool, PrintHeapAtSIGBREAK, true, \
@@ -2349,45 +2376,45 @@
"Trace actions of the GC task threads") \
\
product(bool, PrintParallelOldGCPhaseTimes, false, \
- "Print the time taken by each parallel old gc phase." \
- "PrintGCDetails must also be enabled.") \
+ "Print the time taken by each phase in ParallelOldGC " \
+ "(PrintGCDetails must also be enabled)") \
\
develop(bool, TraceParallelOldGCMarkingPhase, false, \
- "Trace parallel old gc marking phase") \
+ "Trace marking phase in ParallelOldGC") \
\
develop(bool, TraceParallelOldGCSummaryPhase, false, \
- "Trace parallel old gc summary phase") \
+ "Trace summary phase in ParallelOldGC") \
\
develop(bool, TraceParallelOldGCCompactionPhase, false, \
- "Trace parallel old gc compaction phase") \
+ "Trace compaction phase in ParallelOldGC") \
\
develop(bool, TraceParallelOldGCDensePrefix, false, \
- "Trace parallel old gc dense prefix computation") \
+ "Trace dense prefix computation for ParallelOldGC") \
\
develop(bool, IgnoreLibthreadGPFault, false, \
"Suppress workaround for libthread GP fault") \
\
product(bool, PrintJNIGCStalls, false, \
- "Print diagnostic message when GC is stalled" \
+ "Print diagnostic message when GC is stalled " \
"by JNI critical section") \
\
experimental(double, ObjectCountCutOffPercent, 0.5, \
"The percentage of the used heap that the instances of a class " \
- "must occupy for the class to generate a trace event.") \
+ "must occupy for the class to generate a trace event") \
\
/* GC log rotation setting */ \
\
product(bool, UseGCLogFileRotation, false, \
- "Prevent large gclog file for long running app. " \
- "Requires -Xloggc:<filename>") \
+ "Rotate gclog files (for long running applications). It requires "\
+ "-Xloggc:<filename>") \
\
product(uintx, NumberOfGCLogFiles, 0, \
- "Number of gclog files in rotation, " \
- "Default: 0, no rotation") \
+ "Number of gclog files in rotation " \
+ "(default: 0, no rotation)") \
\
product(uintx, GCLogFileSize, 0, \
- "GC log file size, Default: 0 bytes, no rotation " \
- "Only valid with UseGCLogFileRotation") \
+ "GC log file size (default: 0 bytes, no rotation). " \
+ "It requires UseGCLogFileRotation") \
\
/* JVMTI heap profiling */ \
\
@@ -2464,40 +2491,40 @@
"Generate range checks for array accesses") \
\
develop_pd(bool, ImplicitNullChecks, \
- "generate code for implicit null checks") \
+ "Generate code for implicit null checks") \
\
product(bool, PrintSafepointStatistics, false, \
- "print statistics about safepoint synchronization") \
+ "Print statistics about safepoint synchronization") \
\
product(intx, PrintSafepointStatisticsCount, 300, \
- "total number of safepoint statistics collected " \
+ "Total number of safepoint statistics collected " \
"before printing them out") \
\
product(intx, PrintSafepointStatisticsTimeout, -1, \
- "print safepoint statistics only when safepoint takes" \
- " more than PrintSafepointSatisticsTimeout in millis") \
+ "Print safepoint statistics only when safepoint takes " \
+ "more than PrintSafepointSatisticsTimeout in millis") \
\
product(bool, TraceSafepointCleanupTime, false, \
- "print the break down of clean up tasks performed during" \
- " safepoint") \
+ "Print the break down of clean up tasks performed during " \
+ "safepoint") \
\
product(bool, Inline, true, \
- "enable inlining") \
+ "Enable inlining") \
\
product(bool, ClipInlining, true, \
- "clip inlining if aggregate method exceeds DesiredMethodLimit") \
+ "Clip inlining if aggregate method exceeds DesiredMethodLimit") \
\
develop(bool, UseCHA, true, \
- "enable CHA") \
+ "Enable CHA") \
\
product(bool, UseTypeProfile, true, \
"Check interpreter profile for historically monomorphic calls") \
\
notproduct(bool, TimeCompiler, false, \
- "time the compiler") \
+ "Time the compiler") \
\
diagnostic(bool, PrintInlining, false, \
- "prints inlining optimizations") \
+ "Print inlining optimizations") \
\
product(bool, UsePopCountInstruction, false, \
"Use population count instruction") \
@@ -2509,57 +2536,59 @@
"Print when methods are replaced do to recompilation") \
\
develop(bool, PrintMethodFlushing, false, \
- "print the nmethods being flushed") \
+ "Print the nmethods being flushed") \
\
develop(bool, UseRelocIndex, false, \
- "use an index to speed random access to relocations") \
+ "Use an index to speed random access to relocations") \
\
develop(bool, StressCodeBuffers, false, \
- "Exercise code buffer expansion and other rare state changes") \
+ "Exercise code buffer expansion and other rare state changes") \
\
diagnostic(bool, DebugNonSafepoints, trueInDebug, \
- "Generate extra debugging info for non-safepoints in nmethods") \
+ "Generate extra debugging information for non-safepoints in " \
+ "nmethods") \
\
product(bool, PrintVMOptions, false, \
- "Print flags that appeared on the command line") \
+ "Print flags that appeared on the command line") \
\
product(bool, IgnoreUnrecognizedVMOptions, false, \
- "Ignore unrecognized VM options") \
+ "Ignore unrecognized VM options") \
\
product(bool, PrintCommandLineFlags, false, \
- "Print flags specified on command line or set by ergonomics") \
+ "Print flags specified on command line or set by ergonomics") \
\
product(bool, PrintFlagsInitial, false, \
- "Print all VM flags before argument processing and exit VM") \
+ "Print all VM flags before argument processing and exit VM") \
\
product(bool, PrintFlagsFinal, false, \
- "Print all VM flags after argument and ergonomic processing") \
+ "Print all VM flags after argument and ergonomic processing") \
\
notproduct(bool, PrintFlagsWithComments, false, \
- "Print all VM flags with default values and descriptions and exit")\
+ "Print all VM flags with default values and descriptions and " \
+ "exit") \
\
diagnostic(bool, SerializeVMOutput, true, \
- "Use a mutex to serialize output to tty and LogFile") \
+ "Use a mutex to serialize output to tty and LogFile") \
\
diagnostic(bool, DisplayVMOutput, true, \
- "Display all VM output on the tty, independently of LogVMOutput") \
+ "Display all VM output on the tty, independently of LogVMOutput") \
\
diagnostic(bool, LogVMOutput, false, \
- "Save VM output to LogFile") \
+ "Save VM output to LogFile") \
\
diagnostic(ccstr, LogFile, NULL, \
- "If LogVMOutput or LogCompilation is on, save VM output to " \
- "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)") \
+ "If LogVMOutput or LogCompilation is on, save VM output to " \
+ "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)")\
\
product(ccstr, ErrorFile, NULL, \
- "If an error occurs, save the error data to this file " \
- "[default: ./hs_err_pid%p.log] (%p replaced with pid)") \
+ "If an error occurs, save the error data to this file " \
+ "[default: ./hs_err_pid%p.log] (%p replaced with pid)") \
\
product(bool, DisplayVMOutputToStderr, false, \
- "If DisplayVMOutput is true, display all VM output to stderr") \
+ "If DisplayVMOutput is true, display all VM output to stderr") \
\
product(bool, DisplayVMOutputToStdout, false, \
- "If DisplayVMOutput is true, display all VM output to stdout") \
+ "If DisplayVMOutput is true, display all VM output to stdout") \
\
product(bool, UseHeavyMonitors, false, \
"use heavyweight instead of lightweight Java monitors") \
@@ -2583,7 +2612,7 @@
\
notproduct(ccstr, AbortVMOnExceptionMessage, NULL, \
"Call fatal if the exception pointed by AbortVMOnException " \
- "has this message.") \
+ "has this message") \
\
develop(bool, DebugVtables, false, \
"add debugging code to vtable dispatch") \
@@ -2650,29 +2679,29 @@
\
/* statistics */ \
develop(bool, CountCompiledCalls, false, \
- "counts method invocations") \
+ "Count method invocations") \
\
notproduct(bool, CountRuntimeCalls, false, \
- "counts VM runtime calls") \
+ "Count VM runtime calls") \
\
develop(bool, CountJNICalls, false, \
- "counts jni method invocations") \
+ "Count jni method invocations") \
\
notproduct(bool, CountJVMCalls, false, \
- "counts jvm method invocations") \
+ "Count jvm method invocations") \
\
notproduct(bool, CountRemovableExceptions, false, \
- "count exceptions that could be replaced by branches due to " \
+ "Count exceptions that could be replaced by branches due to " \
"inlining") \
\
notproduct(bool, ICMissHistogram, false, \
- "produce histogram of IC misses") \
+ "Produce histogram of IC misses") \
\
notproduct(bool, PrintClassStatistics, false, \
- "prints class statistics at end of run") \
+ "Print class statistics at end of run") \
\
notproduct(bool, PrintMethodStatistics, false, \
- "prints method statistics at end of run") \
+ "Print method statistics at end of run") \
\
/* interpreter */ \
develop(bool, ClearInterpreterLocals, false, \
@@ -2686,7 +2715,7 @@
"Rewrite frequently used bytecode pairs into a single bytecode") \
\
diagnostic(bool, PrintInterpreter, false, \
- "Prints the generated interpreter code") \
+ "Print the generated interpreter code") \
\
product(bool, UseInterpreter, true, \
"Use interpreter for non-compiled methods") \
@@ -2704,8 +2733,8 @@
"Use fast method entry code for accessor methods") \
\
product_pd(bool, UseOnStackReplacement, \
- "Use on stack replacement, calls runtime if invoc. counter " \
- "overflows in loop") \
+ "Use on stack replacement, calls runtime if invoc. counter " \
+ "overflows in loop") \
\
notproduct(bool, TraceOnStackReplacement, false, \
"Trace on stack replacement") \
@@ -2753,10 +2782,10 @@
"Trace frequency based inlining") \
\
develop_pd(bool, InlineIntrinsics, \
- "Inline intrinsics that can be statically resolved") \
+ "Inline intrinsics that can be statically resolved") \
\
product_pd(bool, ProfileInterpreter, \
- "Profile at the bytecode level during interpretation") \
+ "Profile at the bytecode level during interpretation") \
\
develop_pd(bool, ProfileTraps, \
"Profile deoptimization traps at the bytecode level") \
@@ -2766,7 +2795,7 @@
"CompileThreshold) before using the method's profile") \
\
develop(bool, PrintMethodData, false, \
- "Print the results of +ProfileInterpreter at end of run") \
+ "Print the results of +ProfileInterpreter at end of run") \
\
develop(bool, VerifyDataPointer, trueInDebug, \
"Verify the method data pointer during interpreter profiling") \
@@ -2781,7 +2810,7 @@
\
/* compilation */ \
product(bool, UseCompiler, true, \
- "use compilation") \
+ "Use Just-In-Time compilation") \
\
develop(bool, TraceCompilationPolicy, false, \
"Trace compilation policy") \
@@ -2790,20 +2819,21 @@
"Time the compilation policy") \
\
product(bool, UseCounterDecay, true, \
- "adjust recompilation counters") \
+ "Adjust recompilation counters") \
\
develop(intx, CounterHalfLifeTime, 30, \
- "half-life time of invocation counters (in secs)") \
+ "Half-life time of invocation counters (in seconds)") \
\
develop(intx, CounterDecayMinIntervalLength, 500, \
- "Min. ms. between invocation of CounterDecay") \
+ "The minimum interval (in milliseconds) between invocation of " \
+ "CounterDecay") \
\
product(bool, AlwaysCompileLoopMethods, false, \
- "when using recompilation, never interpret methods " \
+ "When using recompilation, never interpret methods " \
"containing loops") \
\
product(bool, DontCompileHugeMethods, true, \
- "don't compile methods > HugeMethodLimit") \
+ "Do not compile methods > HugeMethodLimit") \
\
/* Bytecode escape analysis estimation. */ \
product(bool, EstimateArgEscape, true, \
@@ -2813,10 +2843,10 @@
"How much tracing to do of bytecode escape analysis estimates") \
\
product(intx, MaxBCEAEstimateLevel, 5, \
- "Maximum number of nested calls that are analyzed by BC EA.") \
+ "Maximum number of nested calls that are analyzed by BC EA") \
\
product(intx, MaxBCEAEstimateSize, 150, \
- "Maximum bytecode size of a method to be analyzed by BC EA.") \
+ "Maximum bytecode size of a method to be analyzed by BC EA") \
\
product(intx, AllocatePrefetchStyle, 1, \
"0 = no prefetch, " \
@@ -2831,7 +2861,8 @@
"Number of lines to prefetch ahead of array allocation pointer") \
\
product(intx, AllocateInstancePrefetchLines, 1, \
- "Number of lines to prefetch ahead of instance allocation pointer") \
+ "Number of lines to prefetch ahead of instance allocation " \
+ "pointer") \
\
product(intx, AllocatePrefetchStepSize, 16, \
"Step size in bytes of sequential prefetch instructions") \
@@ -2851,8 +2882,8 @@
"(0 means off)") \
\
product(intx, MaxJavaStackTraceDepth, 1024, \
- "Max. no. of lines in the stack trace for Java exceptions " \
- "(0 means all)") \
+ "The maximum number of lines in the stack trace for Java " \
+ "exceptions (0 means all)") \
\
NOT_EMBEDDED(diagnostic(intx, GuaranteedSafepointInterval, 1000, \
"Guarantee a safepoint (at least) every so many milliseconds " \
@@ -2876,10 +2907,10 @@
"result in more aggressive sweeping") \
\
notproduct(bool, LogSweeper, false, \
- "Keep a ring buffer of sweeper activity") \
+ "Keep a ring buffer of sweeper activity") \
\
notproduct(intx, SweeperLogEntries, 1024, \
- "Number of records in the ring buffer of sweeper activity") \
+ "Number of records in the ring buffer of sweeper activity") \
\
notproduct(intx, MemProfilingInterval, 500, \
"Time between each invocation of the MemProfiler") \
@@ -2922,34 +2953,35 @@
"less than this") \
\
product(intx, MaxInlineSize, 35, \
- "maximum bytecode size of a method to be inlined") \
+ "The maximum bytecode size of a method to be inlined") \
\
product_pd(intx, FreqInlineSize, \
- "maximum bytecode size of a frequent method to be inlined") \
+ "The maximum bytecode size of a frequent method to be inlined") \
\
product(intx, MaxTrivialSize, 6, \
- "maximum bytecode size of a trivial method to be inlined") \
+ "The maximum bytecode size of a trivial method to be inlined") \
\
product(intx, MinInliningThreshold, 250, \
- "min. invocation count a method needs to have to be inlined") \
+ "The minimum invocation count a method needs to have to be " \
+ "inlined") \
\
develop(intx, MethodHistogramCutoff, 100, \
- "cutoff value for method invoc. histogram (+CountCalls)") \
+ "The cutoff value for method invocation histogram (+CountCalls)") \
\
develop(intx, ProfilerNumberOfInterpretedMethods, 25, \
- "# of interpreted methods to show in profile") \
+ "Number of interpreted methods to show in profile") \
\
develop(intx, ProfilerNumberOfCompiledMethods, 25, \
- "# of compiled methods to show in profile") \
+ "Number of compiled methods to show in profile") \
\
develop(intx, ProfilerNumberOfStubMethods, 25, \
- "# of stub methods to show in profile") \
+ "Number of stub methods to show in profile") \
\
develop(intx, ProfilerNumberOfRuntimeStubNodes, 25, \
- "# of runtime stub nodes to show in profile") \
+ "Number of runtime stub nodes to show in profile") \
\
product(intx, ProfileIntervalsTicks, 100, \
- "# of ticks between printing of interval profile " \
+ "Number of ticks between printing of interval profile " \
"(+ProfileIntervals)") \
\
notproduct(intx, ScavengeALotInterval, 1, \
@@ -2970,7 +3002,7 @@
\
develop(intx, MinSleepInterval, 1, \
"Minimum sleep() interval (milliseconds) when " \
- "ConvertSleepToYield is off (used for SOLARIS)") \
+ "ConvertSleepToYield is off (used for Solaris)") \
\
develop(intx, ProfilerPCTickThreshold, 15, \
"Number of ticks in a PC buckets to be a hotspot") \
@@ -2985,22 +3017,22 @@
"Mark nmethods non-entrant at registration") \
\
diagnostic(intx, MallocVerifyInterval, 0, \
- "if non-zero, verify C heap after every N calls to " \
+ "If non-zero, verify C heap after every N calls to " \
"malloc/realloc/free") \
\
diagnostic(intx, MallocVerifyStart, 0, \
- "if non-zero, start verifying C heap after Nth call to " \
+ "If non-zero, start verifying C heap after Nth call to " \
"malloc/realloc/free") \
\
diagnostic(uintx, MallocMaxTestWords, 0, \
- "if non-zero, max # of Words that malloc/realloc can allocate " \
- "(for testing only)") \
+ "If non-zero, maximum number of words that malloc/realloc can " \
+ "allocate (for testing only)") \
\
product(intx, TypeProfileWidth, 2, \
- "number of receiver types to record in call/cast profile") \
+ "Number of receiver types to record in call/cast profile") \
\
develop(intx, BciProfileWidth, 2, \
- "number of return bci's to record in ret profile") \
+ "Number of return bci's to record in ret profile") \
\
product(intx, PerMethodRecompilationCutoff, 400, \
"After recompiling N times, stay in the interpreter (-1=>'Inf')") \
@@ -3067,7 +3099,7 @@
"Percentage of Eden that can be wasted") \
\
product(uintx, TLABRefillWasteFraction, 64, \
- "Max TLAB waste at a refill (internal fragmentation)") \
+ "Maximum TLAB waste at a refill (internal fragmentation)") \
\
product(uintx, TLABWasteIncrement, 4, \
"Increment allowed waste at slow allocation") \
@@ -3076,7 +3108,7 @@
"Ratio of eden/survivor space size") \
\
product(uintx, NewRatio, 2, \
- "Ratio of new/old generation sizes") \
+ "Ratio of old/new generation sizes") \
\
product_pd(uintx, NewSizeThreadIncrease, \
"Additional size added to desired new generation size per " \
@@ -3093,28 +3125,30 @@
"class pointers are used") \
\
product(uintx, MinHeapFreeRatio, 40, \
- "Min percentage of heap free after GC to avoid expansion") \
+ "The minimum percentage of heap free after GC to avoid expansion")\
\
product(uintx, MaxHeapFreeRatio, 70, \
- "Max percentage of heap free after GC to avoid shrinking") \
+ "The maximum percentage of heap free after GC to avoid shrinking")\
\
product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
"Number of milliseconds per MB of free space in the heap") \
\
product(uintx, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
- "Min change in heap space due to GC (in bytes)") \
+ "The minimum change in heap space due to GC (in bytes)") \
\
product(uintx, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
- "Min expansion of Metaspace (in bytes)") \
+ "The minimum expansion of Metaspace (in bytes)") \
\
product(uintx, MinMetaspaceFreeRatio, 40, \
- "Min percentage of Metaspace free after GC to avoid expansion") \
+ "The minimum percentage of Metaspace free after GC to avoid " \
+ "expansion") \
\
product(uintx, MaxMetaspaceFreeRatio, 70, \
- "Max percentage of Metaspace free after GC to avoid shrinking") \
+ "The maximum percentage of Metaspace free after GC to avoid " \
+ "shrinking") \
\
product(uintx, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \
- "Max expansion of Metaspace without full GC (in bytes)") \
+ "The maximum expansion of Metaspace without full GC (in bytes)") \
\
product(uintx, QueuedAllocationWarningCount, 0, \
"Number of times an allocation that queues behind a GC " \
@@ -3136,13 +3170,14 @@
"Desired percentage of survivor space used after scavenge") \
\
product(uintx, MarkSweepDeadRatio, 5, \
- "Percentage (0-100) of the old gen allowed as dead wood." \
- "Serial mark sweep treats this as both the min and max value." \
- "CMS uses this value only if it falls back to mark sweep." \
- "Par compact uses a variable scale based on the density of the" \
- "generation and treats this as the max value when the heap is" \
- "either completely full or completely empty. Par compact also" \
- "has a smaller default value; see arguments.cpp.") \
+ "Percentage (0-100) of the old gen allowed as dead wood. " \
+ "Serial mark sweep treats this as both the minimum and maximum " \
+ "value. " \
+ "CMS uses this value only if it falls back to mark sweep. " \
+ "Par compact uses a variable scale based on the density of the " \
+ "generation and treats this as the maximum value when the heap " \
+ "is either completely full or completely empty. Par compact " \
+ "also has a smaller default value; see arguments.cpp.") \
\
product(uintx, MarkSweepAlwaysCompactCount, 4, \
"How often should we fully compact the heap (ignoring the dead " \
@@ -3161,27 +3196,27 @@
"Census for CMS' FreeListSpace") \
\
develop(uintx, GCExpandToAllocateDelayMillis, 0, \
- "Delay in ms between expansion and allocation") \
+ "Delay between expansion and allocation (in milliseconds)") \
\
develop(uintx, GCWorkerDelayMillis, 0, \
- "Delay in ms in scheduling GC workers") \
+ "Delay in scheduling GC workers (in milliseconds)") \
\
product(intx, DeferThrSuspendLoopCount, 4000, \
"(Unstable) Number of times to iterate in safepoint loop " \
- " before blocking VM threads ") \
+ "before blocking VM threads ") \
\
product(intx, DeferPollingPageLoopCount, -1, \
"(Unsafe,Unstable) Number of iterations in safepoint loop " \
"before changing safepoint polling page to RO ") \
\
- product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
+ product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
\
product(bool, PSChunkLargeArrays, true, \
- "true: process large arrays in chunks") \
+ "Process large arrays in chunks") \
\
product(uintx, GCDrainStackTargetSize, 64, \
- "how many entries we'll try to leave on the stack during " \
- "parallel GC") \
+ "Number of entries we will try to leave on the stack " \
+ "during parallel gc") \
\
/* stack parameters */ \
product_pd(intx, StackYellowPages, \
@@ -3191,8 +3226,8 @@
"Number of red zone (unrecoverable overflows) pages") \
\
product_pd(intx, StackShadowPages, \
- "Number of shadow zone (for overflow checking) pages" \
- " this should exceed the depth of the VM and native call stack") \
+ "Number of shadow zone (for overflow checking) pages " \
+ "this should exceed the depth of the VM and native call stack") \
\
product_pd(intx, ThreadStackSize, \
"Thread Stack Size (in Kbytes)") \
@@ -3232,16 +3267,16 @@
"Reserved code cache size (in bytes) - maximum code cache size") \
\
product(uintx, CodeCacheMinimumFreeSpace, 500*K, \
- "When less than X space left, we stop compiling.") \
+ "When less than X space left, we stop compiling") \
\
product_pd(uintx, CodeCacheExpansionSize, \
"Code cache expansion size (in bytes)") \
\
develop_pd(uintx, CodeCacheMinBlockLength, \
- "Minimum number of segments in a code cache block.") \
+ "Minimum number of segments in a code cache block") \
\
notproduct(bool, ExitOnFullCodeCache, false, \
- "Exit the VM if we fill the code cache.") \
+ "Exit the VM if we fill the code cache") \
\
product(bool, UseCodeCacheFlushing, true, \
"Attempt to clean the code cache before shutting off compiler") \
@@ -3252,31 +3287,31 @@
"switch") \
\
develop(intx, StopInterpreterAt, 0, \
- "Stops interpreter execution at specified bytecode number") \
+ "Stop interpreter execution at specified bytecode number") \
\
develop(intx, TraceBytecodesAt, 0, \
- "Traces bytecodes starting with specified bytecode number") \
+ "Trace bytecodes starting with specified bytecode number") \
\
/* compiler interface */ \
develop(intx, CIStart, 0, \
- "the id of the first compilation to permit") \
+ "The id of the first compilation to permit") \
\
develop(intx, CIStop, -1, \
- "the id of the last compilation to permit") \
+ "The id of the last compilation to permit") \
\
develop(intx, CIStartOSR, 0, \
- "the id of the first osr compilation to permit " \
+ "The id of the first osr compilation to permit " \
"(CICountOSR must be on)") \
\
develop(intx, CIStopOSR, -1, \
- "the id of the last osr compilation to permit " \
+ "The id of the last osr compilation to permit " \
"(CICountOSR must be on)") \
\
develop(intx, CIBreakAtOSR, -1, \
- "id of osr compilation to break at") \
+ "The id of osr compilation to break at") \
\
develop(intx, CIBreakAt, -1, \
- "id of compilation to break at") \
+ "The id of compilation to break at") \
\
product(ccstrlist, CompileOnly, "", \
"List of methods (pkg/class.name) to restrict compilation to") \
@@ -3295,11 +3330,11 @@
"[default: ./replay_pid%p.log] (%p replaced with pid)") \
\
develop(intx, ReplaySuppressInitializers, 2, \
- "Controls handling of class initialization during replay" \
- "0 - don't do anything special" \
- "1 - treat all class initializers as empty" \
- "2 - treat class initializers for application classes as empty" \
- "3 - allow all class initializers to run during bootstrap but" \
+ "Control handling of class initialization during replay: " \
+ "0 - don't do anything special; " \
+ "1 - treat all class initializers as empty; " \
+ "2 - treat class initializers for application classes as empty; " \
+ "3 - allow all class initializers to run during bootstrap but " \
" pretend they are empty after starting replay") \
\
develop(bool, ReplayIgnoreInitErrors, false, \
@@ -3328,14 +3363,15 @@
"0 : Normal. "\
" VM chooses priorities that are appropriate for normal "\
" applications. On Solaris NORM_PRIORITY and above are mapped "\
- " to normal native priority. Java priorities below NORM_PRIORITY"\
- " map to lower native priority values. On Windows applications"\
- " are allowed to use higher native priorities. However, with "\
- " ThreadPriorityPolicy=0, VM will not use the highest possible"\
- " native priority, THREAD_PRIORITY_TIME_CRITICAL, as it may "\
- " interfere with system threads. On Linux thread priorities "\
- " are ignored because the OS does not support static priority "\
- " in SCHED_OTHER scheduling class which is the only choice for"\
+ " to normal native priority. Java priorities below " \
+ " NORM_PRIORITY map to lower native priority values. On "\
+ " Windows applications are allowed to use higher native "\
+ " priorities. However, with ThreadPriorityPolicy=0, VM will "\
+ " not use the highest possible native priority, "\
+ " THREAD_PRIORITY_TIME_CRITICAL, as it may interfere with "\
+ " system threads. On Linux thread priorities are ignored "\
+ " because the OS does not support static priority in "\
+ " SCHED_OTHER scheduling class which is the only choice for "\
" non-root, non-realtime applications. "\
"1 : Aggressive. "\
" Java thread priorities map over to the entire range of "\
@@ -3366,16 +3402,35 @@
product(bool, VMThreadHintNoPreempt, false, \
"(Solaris only) Give VM thread an extra quanta") \
\
- product(intx, JavaPriority1_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority2_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority3_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority4_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority5_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority6_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority7_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority8_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority9_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority10_To_OSPriority,-1, "Map Java priorities to OS priorities") \
+ product(intx, JavaPriority1_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority2_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority3_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority4_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority5_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority6_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority7_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority8_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority9_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority10_To_OSPriority,-1, \
+ "Map Java priorities to OS priorities") \
\
experimental(bool, UseCriticalJavaThreadPriority, false, \
"Java thread priority 10 maps to critical scheduling priority") \
@@ -3406,37 +3461,38 @@
"Used with +TraceLongCompiles") \
\
product(intx, StarvationMonitorInterval, 200, \
- "Pause between each check in ms") \
+ "Pause between each check (in milliseconds)") \
\
/* recompilation */ \
product_pd(intx, CompileThreshold, \
"number of interpreted method invocations before (re-)compiling") \
\
product_pd(intx, BackEdgeThreshold, \
- "Interpreter Back edge threshold at which an OSR compilation is invoked")\
+ "Interpreter Back edge threshold at which an OSR compilation is " \
+ "invoked") \
\
product(intx, Tier0InvokeNotifyFreqLog, 7, \
- "Interpreter (tier 0) invocation notification frequency.") \
+ "Interpreter (tier 0) invocation notification frequency") \
\
product(intx, Tier2InvokeNotifyFreqLog, 11, \
- "C1 without MDO (tier 2) invocation notification frequency.") \
+ "C1 without MDO (tier 2) invocation notification frequency") \
\
product(intx, Tier3InvokeNotifyFreqLog, 10, \
"C1 with MDO profiling (tier 3) invocation notification " \
- "frequency.") \
+ "frequency") \
\
product(intx, Tier23InlineeNotifyFreqLog, 20, \
"Inlinee invocation (tiers 2 and 3) notification frequency") \
\
product(intx, Tier0BackedgeNotifyFreqLog, 10, \
- "Interpreter (tier 0) invocation notification frequency.") \
+ "Interpreter (tier 0) invocation notification frequency") \
\
product(intx, Tier2BackedgeNotifyFreqLog, 14, \
- "C1 without MDO (tier 2) invocation notification frequency.") \
+ "C1 without MDO (tier 2) invocation notification frequency") \
\
product(intx, Tier3BackedgeNotifyFreqLog, 13, \
"C1 with MDO profiling (tier 3) invocation notification " \
- "frequency.") \
+ "frequency") \
\
product(intx, Tier2CompileThreshold, 0, \
"threshold at which tier 2 compilation is invoked") \
@@ -3453,7 +3509,7 @@
\
product(intx, Tier3CompileThreshold, 2000, \
"Threshold at which tier 3 compilation is invoked (invocation " \
- "minimum must be satisfied.") \
+ "minimum must be satisfied") \
\
product(intx, Tier3BackEdgeThreshold, 60000, \
"Back edge threshold at which tier 3 OSR compilation is invoked") \
@@ -3467,7 +3523,7 @@
\
product(intx, Tier4CompileThreshold, 15000, \
"Threshold at which tier 4 compilation is invoked (invocation " \
- "minimum must be satisfied.") \
+ "minimum must be satisfied") \
\
product(intx, Tier4BackEdgeThreshold, 40000, \
"Back edge threshold at which tier 4 OSR compilation is invoked") \
@@ -3496,12 +3552,12 @@
"Stop at given compilation level") \
\
product(intx, Tier0ProfilingStartPercentage, 200, \
- "Start profiling in interpreter if the counters exceed tier 3" \
+ "Start profiling in interpreter if the counters exceed tier 3 " \
"thresholds by the specified percentage") \
\
product(uintx, IncreaseFirstTierCompileThresholdAt, 50, \
- "Increase the compile threshold for C1 compilation if the code" \
- "cache is filled by the specified percentage.") \
+ "Increase the compile threshold for C1 compilation if the code " \
+ "cache is filled by the specified percentage") \
\
product(intx, TieredRateUpdateMinTime, 1, \
"Minimum rate sampling interval (in milliseconds)") \
@@ -3516,24 +3572,26 @@
"Print tiered events notifications") \
\
product_pd(intx, OnStackReplacePercentage, \
- "NON_TIERED number of method invocations/branches (expressed as %"\
- "of CompileThreshold) before (re-)compiling OSR code") \
+ "NON_TIERED number of method invocations/branches (expressed as " \
+ "% of CompileThreshold) before (re-)compiling OSR code") \
\
product(intx, InterpreterProfilePercentage, 33, \
- "NON_TIERED number of method invocations/branches (expressed as %"\
- "of CompileThreshold) before profiling in the interpreter") \
+ "NON_TIERED number of method invocations/branches (expressed as " \
+ "% of CompileThreshold) before profiling in the interpreter") \
\
develop(intx, MaxRecompilationSearchLength, 10, \
- "max. # frames to inspect searching for recompilee") \
+ "The maximum number of frames to inspect when searching for " \
+ "recompilee") \
\
develop(intx, MaxInterpretedSearchLength, 3, \
- "max. # interp. frames to skip when searching for recompilee") \
+ "The maximum number of interpreted frames to skip when searching "\
+ "for recompilee") \
\
develop(intx, DesiredMethodLimit, 8000, \
- "desired max. method size (in bytecodes) after inlining") \
+ "The desired maximum method size (in bytecodes) after inlining") \
\
develop(intx, HugeMethodLimit, 8000, \
- "don't compile methods larger than this if " \
+ "Don't compile methods larger than this if " \
"+DontCompileHugeMethods") \
\
/* New JDK 1.4 reflection implementation */ \
@@ -3555,7 +3613,7 @@
"in InvocationTargetException. See 6531596") \
\
develop(bool, VerifyLambdaBytecodes, false, \
- "Force verification of jdk 8 lambda metafactory bytecodes.") \
+ "Force verification of jdk 8 lambda metafactory bytecodes") \
\
develop(intx, FastSuperclassLimit, 8, \
"Depth of hardwired instanceof accelerator array") \
@@ -3579,18 +3637,19 @@
/* flags for performance data collection */ \
\
product(bool, UsePerfData, falseInEmbedded, \
- "Flag to disable jvmstat instrumentation for performance testing" \
- "and problem isolation purposes.") \
+ "Flag to disable jvmstat instrumentation for performance testing "\
+ "and problem isolation purposes") \
\
product(bool, PerfDataSaveToFile, false, \
"Save PerfData memory to hsperfdata_<pid> file on exit") \
\
product(ccstr, PerfDataSaveFile, NULL, \
- "Save PerfData memory to the specified absolute pathname," \
- "%p in the file name if present will be replaced by pid") \
- \
- product(intx, PerfDataSamplingInterval, 50 /*ms*/, \
- "Data sampling interval in milliseconds") \
+ "Save PerfData memory to the specified absolute pathname. " \
+ "The string %p in the file name (if present) " \
+ "will be replaced by pid") \
+ \
+ product(intx, PerfDataSamplingInterval, 50, \
+ "Data sampling interval (in milliseconds)") \
\
develop(bool, PerfTraceDataCreation, false, \
"Trace creation of Performance Data Entries") \
@@ -3615,7 +3674,7 @@
"Bypass Win32 file system criteria checks (Windows Only)") \
\
product(intx, UnguardOnExecutionViolation, 0, \
- "Unguard page and retry on no-execute fault (Win32 only)" \
+ "Unguard page and retry on no-execute fault (Win32 only) " \
"0=off, 1=conservative, 2=aggressive") \
\
/* Serviceability Support */ \
@@ -3624,7 +3683,7 @@
"Create JMX Management Server") \
\
product(bool, DisableAttachMechanism, false, \
- "Disable mechanism that allows tools to attach to this VM") \
+ "Disable mechanism that allows tools to attach to this VM") \
\
product(bool, StartAttachListener, false, \
"Always start Attach Listener at VM startup") \
@@ -3647,9 +3706,9 @@
"Require shared spaces for metadata") \
\
product(bool, DumpSharedSpaces, false, \
- "Special mode: JVM reads a class list, loads classes, builds " \
- "shared spaces, and dumps the shared spaces to a file to be " \
- "used in future JVM runs.") \
+ "Special mode: JVM reads a class list, loads classes, builds " \
+ "shared spaces, and dumps the shared spaces to a file to be " \
+ "used in future JVM runs") \
\
product(bool, PrintSharedSpaces, false, \
"Print usage of shared spaces") \
@@ -3722,7 +3781,7 @@
"Relax the access control checks in the verifier") \
\
diagnostic(bool, PrintDTraceDOF, false, \
- "Print the DTrace DOF passed to the system for JSDT probes") \
+ "Print the DTrace DOF passed to the system for JSDT probes") \
\
product(uintx, StringTableSize, defaultStringTableSize, \
"Number of buckets in the interned String table") \
@@ -3738,8 +3797,8 @@
\
product(bool, UseVMInterruptibleIO, false, \
"(Unstable, Solaris-specific) Thread interrupt before or with " \
- "EINTR for I/O operations results in OS_INTRPT. The default value"\
- " of this flag is true for JDK 6 and earlier") \
+ "EINTR for I/O operations results in OS_INTRPT. The default " \
+ "value of this flag is true for JDK 6 and earlier") \
\
diagnostic(bool, WhiteBoxAPI, false, \
"Enable internal testing APIs") \
@@ -3760,6 +3819,7 @@
\
product(bool, EnableTracing, false, \
"Enable event-based tracing") \
+ \
product(bool, UseLockedTracing, false, \
"Use locked-tracing when doing event-based tracing")