stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8134972: [BACKOUT] GC: implement ranges (optionally constraints) for those flags that have them missing

Browse Source 
Reviewed-by: jwilhelm
This commit is contained in:
Sangheon Kim 2015-09-02 17:49:46 -07:00
parent 8ebc8387ba
commit c091c7348a
13 changed files with 99 additions and 714 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
hotspot/src/share/vm/gc/g1/g1_globals.hpp
View File

@ -26,7 +26,6 @@
#define SHARE_VM_GC_G1_G1_GLOBALS_HPP
#include "runtime/globals.hpp"
#include <float.h> // for DBL_MAX
//
// Defines all globals flags used by the garbage-first compiler.
//
@ -62,7 +61,6 @@
"update buffer processing info " \
"(0 means do not periodically generate this info); " \
"it also requires -XX:+G1SummarizeRSetStats") \
range(0, max_intx) \
\
diagnostic(bool, G1TraceConcRefinement, false, \
"Trace G1 concurrent refinement") \
@ -73,7 +71,7 @@
product(double, G1ConcMarkStepDurationMillis, 10.0, \
"Target duration of individual concurrent marking steps " \
"in milliseconds.") \
range(1.0, DBL_MAX) \
range(1.0, (double)max_uintx) \
\
product(intx, G1RefProcDrainInterval, 10, \
"The number of discovered reference objects to process before " \
@ -91,11 +89,9 @@
\
product(size_t, G1SATBBufferSize, 1*K, \
"Number of entries in an SATB log buffer.") \
range(1, max_uintx) \
\
develop(intx, G1SATBProcessCompletedThreshold, 20, \
"Number of completed buffers that triggers log processing.") \
range(0, max_jint) \
\
product(uintx, G1SATBBufferEnqueueingThresholdPercent, 60, \
"Before enqueueing them, each mutator thread tries to do some " \
@ -118,31 +114,26 @@
\
product(size_t, G1UpdateBufferSize, 256, \
"Size of an update buffer") \
range(1, NOT_LP64(32*M) LP64_ONLY(1*G)) \
\
product(intx, G1ConcRefinementYellowZone, 0, \
"Number of enqueued update buffers that will " \
"trigger concurrent processing. Will be selected ergonomically " \
"by default.") \
range(0, max_intx) \
\
product(intx, G1ConcRefinementRedZone, 0, \
"Maximum number of enqueued update buffers before mutator " \
"threads start processing new ones instead of enqueueing them. " \
"Will be selected ergonomically by default. Zero will disable " \
"concurrent processing.") \
range(0, max_intx) \
\
product(intx, G1ConcRefinementGreenZone, 0, \
"The number of update buffers that are left in the queue by the " \
"concurrent processing threads. Will be selected ergonomically " \
"by default.") \
range(0, max_intx) \
\
product(intx, G1ConcRefinementServiceIntervalMillis, 300, \
"The last concurrent refinement thread wakes up every " \
"specified number of milliseconds to do miscellaneous work.") \
range(0, max_intx) \
\
product(intx, G1ConcRefinementThresholdStep, 0, \
"Each time the rset update queue increases by this amount " \
@ -152,7 +143,6 @@
product(intx, G1RSetUpdatingPauseTimePercent, 10, \
"A target percentage of time that is allowed to be spend on " \
"process RS update buffers during the collection pause.") \
range(0, 100) \
\
product(bool, G1UseAdaptiveConcRefinement, true, \
"Select green, yellow and red zones adaptively to meet the " \
@ -168,24 +158,18 @@
\
develop(intx, G1RSetRegionEntriesBase, 256, \
"Max number of regions in a fine-grain table per MB.") \
range(1, max_jint) \
\
product(intx, G1RSetRegionEntries, 0, \
"Max number of regions for which we keep bitmaps." \
"Will be set ergonomically by default") \
range(0, max_jint) \
constraint(G1RSetRegionEntriesConstraintFunc,AfterErgo) \
\
develop(intx, G1RSetSparseRegionEntriesBase, 4, \
"Max number of entries per region in a sparse table " \
"per MB.") \
range(1, max_jint) \
\
product(intx, G1RSetSparseRegionEntries, 0, \
"Max number of entries per region in a sparse table." \
"Will be set ergonomically by default.") \
range(0, max_jint) \
constraint(G1RSetSparseRegionEntriesConstraintFunc,AfterErgo) \
\
develop(bool, G1RecordHRRSOops, false, \
"When true, record recent calls to rem set operations.") \
@ -196,7 +180,6 @@
develop(intx, G1MaxVerifyFailures, -1, \
"The maximum number of verification failures to print. " \
"-1 means print all.") \
range(-1, max_jint) \
\
develop(bool, G1ScrubRemSets, true, \
"When true, do RS scrubbing after cleanup.") \
@ -210,13 +193,11 @@
develop(intx, G1YoungSurvRateNumRegionsSummary, 0, \
"the number of regions for which we'll print a surv rate " \
"summary.") \
range(0, max_intx) \
constraint(G1YoungSurvRateNumRegionsSummaryConstraintFunc,AfterErgo)\
\
product(uintx, G1ReservePercent, 10, \
"It determines the minimum reserve we should have in the heap " \
"to minimize the probability of promotion failure.") \
range(0, 50) \
range(0, 100) \
\
diagnostic(bool, G1PrintHeapRegions, false, \
"If set G1 will print information on which regions are being " \
@ -234,13 +215,10 @@
\
product(size_t, G1HeapRegionSize, 0, \
"Size of the G1 regions.") \
range(0, 32*M) \
constraint(G1HeapRegionSizeConstraintFunc,AfterMemoryInit) \
\
product(uintx, G1ConcRefinementThreads, 0, \
"If non-0 is the number of parallel rem set update threads, " \
"otherwise the value is determined ergonomically.") \
range(0, max_jint-1) \
\
develop(bool, G1VerifyCTCleanup, false, \
"Verify card table cleanup.") \
@ -248,7 +226,6 @@
product(size_t, G1RSetScanBlockSize, 64, \
"Size of a work unit of cards claimed by a worker thread" \
"during RSet scanning.") \
range(1, max_uintx) \
\
develop(uintx, G1SecondaryFreeListAppendLength, 5, \
"The number of regions we will add to the secondary free list " \
@ -285,7 +262,6 @@
experimental(uintx, G1NewSizePercent, 5, \
"Percentage (0-100) of the heap size to use as default " \
"minimum young gen size.") \
range(0, 100) \
constraint(G1NewSizePercentConstraintFunc,AfterErgo) \
\
experimental(uintx, G1MixedGCLiveThresholdPercent, 85, \

10
hotspot/src/share/vm/runtime/arguments.cpp
View File

@ -581,10 +581,8 @@ static bool set_bool_flag(char* name, bool value, Flag::Flags origin) {
}
static bool set_fp_numeric_flag(char* name, char* value, Flag::Flags origin) {
char* end;
errno = 0;
double v = strtod(value, &end);
if ((errno != 0) || (*end != 0)) {
double v;
if (sscanf(value, "%lf", &v) != 1) {
return false;
}
@ -718,9 +716,9 @@ bool Arguments::parse_argument(const char* arg, Flag::Flags origin) {
return set_string_flag(name, value, origin);
}
#define SIGNED_FP_NUMBER_RANGE "[-0123456789.eE+]"
#define SIGNED_FP_NUMBER_RANGE "[-0123456789.]"
#define SIGNED_NUMBER_RANGE "[-0123456789]"
#define NUMBER_RANGE "[0123456789eE+-]"
#define NUMBER_RANGE "[0123456789]"
char value[BUFLEN + 1];
char value2[BUFLEN + 1];
if (sscanf(arg, "%" XSTR(BUFLEN) NAME_RANGE "=" "%" XSTR(BUFLEN) SIGNED_NUMBER_RANGE "." "%" XSTR(BUFLEN) NUMBER_RANGE "%c", name, value, value2, &dummy) == 3) {

9
hotspot/src/share/vm/runtime/commandLineFlagConstraintList.cpp
View File

@ -220,7 +220,7 @@ void emit_constraint_double(const char* name, CommandLineFlagConstraintFunc_doub
#define EMIT_CONSTRAINT_CHECK(func, type) , func, CommandLineFlagConstraint::type
// the "name" argument must be a string literal
#define INITIAL_CONSTRAINTS_SIZE 40
#define INITIAL_CONSTRAINTS_SIZE 16
GrowableArray<CommandLineFlagConstraint*>* CommandLineFlagConstraintList::_constraints = NULL;
CommandLineFlagConstraint::ConstraintType CommandLineFlagConstraintList::_validating_type = CommandLineFlagConstraint::AtParse;
@ -274,7 +274,7 @@ void CommandLineFlagConstraintList::init(void) {
EMIT_CONSTRAINT_CHECK));
#endif // COMPILER2
#if INCLUDE_ALL_GCS
#ifndef INCLUDE_ALL_GCS
emit_constraint_no(NULL G1_FLAGS(EMIT_CONSTRAINT_DEVELOPER_FLAG,
EMIT_CONSTRAINT_PD_DEVELOPER_FLAG,
EMIT_CONSTRAINT_PRODUCT_FLAG,
@ -305,7 +305,10 @@ CommandLineFlagConstraint* CommandLineFlagConstraintList::find_if_needs_check(co
// Check constraints for specific constraint type.
bool CommandLineFlagConstraintList::check_constraints(CommandLineFlagConstraint::ConstraintType type) {
guarantee(type > _validating_type, "Constraint check is out of order.");
// Skip if we already checked.
if (type < _validating_type) {
return true;
}
_validating_type = type;
bool status = true;

6
hotspot/src/share/vm/runtime/commandLineFlagConstraintList.hpp
View File

@ -54,9 +54,9 @@ public:
enum ConstraintType {
// Will be validated during argument processing (Arguments::parse_argument).
AtParse = 0,
// Will be validated by CommandLineFlagConstraintList::check_constraints(AfterErgo).
AfterErgo = 1,
// Will be validated by CommandLineFlagConstraintList::check_constraints(AfterMemoryInit).
// Will be validated by CommandLineFlags::check_constraints_of_after_ergo().
AfterErgo = 1,
// Will be validated by CommandLineFlags::check_constraints_of_after_memory_init().
AfterMemoryInit = 2
};

475
hotspot/src/share/vm/runtime/commandLineFlagConstraintsGC.cpp
View File

@ -23,19 +23,16 @@
*/
#include "precompiled.hpp"
#include "gc/shared/collectedHeap.hpp"
#include "gc/shared/collectorPolicy.hpp"
#include "gc/shared/threadLocalAllocBuffer.hpp"
#include "runtime/arguments.hpp"
#include "runtime/commandLineFlagConstraintsGC.hpp"
#include "runtime/commandLineFlagRangeList.hpp"
#include "runtime/globals.hpp"
#include "runtime/globals_extension.hpp"
#include "utilities/defaultStream.hpp"
#if INCLUDE_ALL_GCS
#include "gc/g1/g1_globals.hpp"
#include "gc/g1/heapRegionBounds.inline.hpp"
#include "gc/parallel/parallelScavengeHeap.hpp"
#include "gc/shared/plab.hpp"
#endif // INCLUDE_ALL_GCS
#ifdef COMPILER1
@ -45,63 +42,6 @@
#include "opto/c2_globals.hpp"
#endif // COMPILER2
#if INCLUDE_ALL_GCS
static Flag::Error ParallelGCThreadsAndCMSWorkQueueDrainThreshold(uint threads, uintx threshold, bool verbose) {
// CMSWorkQueueDrainThreshold is verified to be less than max_juint
if (UseConcMarkSweepGC && (threads > (uint)(max_jint / (uint)threshold))) {
CommandLineError::print(verbose,
"ParallelGCThreads (" UINT32_FORMAT ") or CMSWorkQueueDrainThreshold ("
UINTX_FORMAT ") is too large\n",
threads, threshold);
return Flag::VIOLATES_CONSTRAINT;
}
return Flag::SUCCESS;
}
#endif
// As ParallelGCThreads differs among GC modes, we need constraint function.
Flag::Error ParallelGCThreadsConstraintFunc(uint value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
#if INCLUDE_ALL_GCS
// Parallel GC passes ParallelGCThreads when creating GrowableArray as 'int' type parameter.
// So can't exceed with "max_jint"
if (UseParallelGC && (value > (uint)max_jint)) {
CommandLineError::print(verbose,
"ParallelGCThreads (" UINT32_FORMAT ") must be "
"less than or equal to " UINT32_FORMAT " for Parallel GC\n",
value, max_jint);
return Flag::VIOLATES_CONSTRAINT;
}
// To avoid overflow at ParScanClosure::do_oop_work.
if (UseConcMarkSweepGC && (value > (max_jint / 10))) {
CommandLineError::print(verbose,
"ParallelGCThreads (" UINT32_FORMAT ") must be "
"less than or equal to " UINT32_FORMAT " for CMS GC\n",
value, (max_jint / 10));
return Flag::VIOLATES_CONSTRAINT;
}
status = ParallelGCThreadsAndCMSWorkQueueDrainThreshold(value, CMSWorkQueueDrainThreshold, verbose);
#endif
return status;
}
// As ConcGCThreads should be smaller than ParallelGCThreads,
// we need constraint function.
Flag::Error ConcGCThreadsConstraintFunc(uint value, bool verbose) {
#if INCLUDE_ALL_GCS
// CMS and G1 GCs use ConcGCThreads.
if ((UseConcMarkSweepGC || UseG1GC) && (value > ParallelGCThreads)) {
CommandLineError::print(verbose,
"ConcGCThreads (" UINT32_FORMAT ") must be "
"less than or equal to ParallelGCThreads (" UINT32_FORMAT ")\n",
value, ParallelGCThreads);
return Flag::VIOLATES_CONSTRAINT;
}
#endif
return Flag::SUCCESS;
}
static Flag::Error MinPLABSizeBounds(const char* name, size_t value, bool verbose) {
#if INCLUDE_ALL_GCS
if ((UseConcMarkSweepGC || UseG1GC) && (value < PLAB::min_size())) {
@ -129,40 +69,16 @@ static Flag::Error MaxPLABSizeBounds(const char* name, size_t value, bool verbos
}
static Flag::Error MinMaxPLABSizeBounds(const char* name, size_t value, bool verbose) {
Flag::Error status = MinPLABSizeBounds(name, value, verbose);
if (status == Flag::SUCCESS) {
if (MinPLABSizeBounds(name, value, verbose) == Flag::SUCCESS) {
return MaxPLABSizeBounds(name, value, verbose);
}
return status;
return Flag::VIOLATES_CONSTRAINT;
}
Flag::Error YoungPLABSizeConstraintFunc(size_t value, bool verbose) {
return MinMaxPLABSizeBounds("YoungPLABSize", value, verbose);
}
Flag::Error OldPLABSizeConstraintFunc(size_t value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
#if INCLUDE_ALL_GCS
if (UseConcMarkSweepGC) {
if (value == 0) {
CommandLineError::print(verbose,
"OldPLABSize (" SIZE_FORMAT ") must be greater than 0",
value);
return Flag::VIOLATES_CONSTRAINT;
}
// For CMS, OldPLABSize is the number of free blocks of a given size that are used when
// replenishing the local per-worker free list caches.
// For more details, please refer to Arguments::set_cms_and_parnew_gc_flags().
status = MaxPLABSizeBounds("OldPLABSize", value, verbose);
} else {
status = MinMaxPLABSizeBounds("OldPLABSize", value, verbose);
}
#endif
return status;
}
Flag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
if (value > MaxHeapFreeRatio) {
CommandLineError::print(verbose,
@ -187,23 +103,6 @@ Flag::Error MaxHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
}
}
static Flag::Error CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(size_t maxHeap, intx softRef, bool verbose) {
if ((softRef > 0) && ((maxHeap / M) > (max_uintx / softRef))) {
CommandLineError::print(verbose,
"Desired lifetime of SoftReferences cannot be expressed correctly. "
"MaxHeapSize (" SIZE_FORMAT ") or SoftRefLRUPolicyMSPerMB "
"(" INTX_FORMAT ") is too large\n",
maxHeap, softRef);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
}
Flag::Error SoftRefLRUPolicyMSPerMBConstraintFunc(intx value, bool verbose) {
return CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(MaxHeapSize, value, verbose);
}
Flag::Error MinMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) {
if (value > MaxMetaspaceFreeRatio) {
CommandLineError::print(verbose,
@ -228,111 +127,45 @@ Flag::Error MaxMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) {
}
}
// GC workaround for "-XX:+UseConcMarkSweepGC"
// which sets InitialTenuringThreshold to 7 but leaves MaxTenuringThreshold remaining at 6
// and therefore would invalidate the constraint
#define UseConcMarkSweepGCWorkaroundIfNeeded(initial, max) { \
if ((initial == 7) && (max == 6)) { \
return Flag::SUCCESS; \
} \
}
Flag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose) {
#if INCLUDE_ALL_GCS
// InitialTenuringThreshold is only used for ParallelGC.
if (UseParallelGC && (value > MaxTenuringThreshold)) {
CommandLineError::print(verbose,
"InitialTenuringThreshold (" UINTX_FORMAT ") must be "
"less than or equal to MaxTenuringThreshold (" UINTX_FORMAT ")\n",
value, MaxTenuringThreshold);
return Flag::VIOLATES_CONSTRAINT;
UseConcMarkSweepGCWorkaroundIfNeeded(value, MaxTenuringThreshold);
if (value > MaxTenuringThreshold) {
CommandLineError::print(verbose,
"InitialTenuringThreshold (" UINTX_FORMAT ") must be "
"less than or equal to MaxTenuringThreshold (" UINTX_FORMAT ")\n",
value, MaxTenuringThreshold);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
#endif
return Flag::SUCCESS;
}
Flag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose) {
#if INCLUDE_ALL_GCS
// As only ParallelGC uses InitialTenuringThreshold,
// we don't need to compare InitialTenuringThreshold with MaxTenuringThreshold.
if (UseParallelGC && (value < InitialTenuringThreshold)) {
UseConcMarkSweepGCWorkaroundIfNeeded(InitialTenuringThreshold, value);
if (value < InitialTenuringThreshold) {
CommandLineError::print(verbose,
"MaxTenuringThreshold (" UINTX_FORMAT ") must be "
"greater than or equal to InitialTenuringThreshold (" UINTX_FORMAT ")\n",
value, InitialTenuringThreshold);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
#endif
// MaxTenuringThreshold=0 means NeverTenure=false && AlwaysTenure=true
if ((value == 0) && (NeverTenure || !AlwaysTenure)) {
CommandLineError::print(verbose,
"MaxTenuringThreshold (0) should match to NeverTenure=false "
"&& AlwaysTenure=true. But we have NeverTenure=%s "
"AlwaysTenure=%s\n",
NeverTenure ? "true" : "false",
AlwaysTenure ? "true" : "false");
return Flag::VIOLATES_CONSTRAINT;
}
return Flag::SUCCESS;
}
#if INCLUDE_ALL_GCS
Flag::Error G1RSetRegionEntriesConstraintFunc(intx value, bool verbose) {
if (!UseG1GC) return Flag::SUCCESS;
// Default value of G1RSetRegionEntries=0 means will be set ergonomically.
// Minimum value is 1.
if (FLAG_IS_CMDLINE(G1RSetRegionEntries) && (value < 1)) {
CommandLineError::print(verbose,
"G1RSetRegionEntries (" INTX_FORMAT ") must be "
"greater than or equal to 1\n",
value);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
}
Flag::Error G1RSetSparseRegionEntriesConstraintFunc(intx value, bool verbose) {
if (!UseG1GC) return Flag::SUCCESS;
// Default value of G1RSetSparseRegionEntries=0 means will be set ergonomically.
// Minimum value is 1.
if (FLAG_IS_CMDLINE(G1RSetSparseRegionEntries) && (value < 1)) {
CommandLineError::print(verbose,
"G1RSetSparseRegionEntries (" INTX_FORMAT ") must be "
"greater than or equal to 1\n",
value);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
}
Flag::Error G1YoungSurvRateNumRegionsSummaryConstraintFunc(intx value, bool verbose) {
if (!UseG1GC) return Flag::SUCCESS;
if (value > (intx)HeapRegionBounds::target_number()) {
CommandLineError::print(verbose,
"G1YoungSurvRateNumRegionsSummary (" INTX_FORMAT ") must be "
"less than or equal to region count (" SIZE_FORMAT ")\n",
value, HeapRegionBounds::target_number());
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
}
Flag::Error G1HeapRegionSizeConstraintFunc(size_t value, bool verbose) {
if (!UseG1GC) return Flag::SUCCESS;
// Default value of G1HeapRegionSize=0 means will be set ergonomically.
if (FLAG_IS_CMDLINE(G1HeapRegionSize) && (value < HeapRegionBounds::min_size())) {
CommandLineError::print(verbose,
"G1HeapRegionSize (" SIZE_FORMAT ") must be "
"greater than or equal to ergonomic heap region minimum size\n",
value);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
}
Flag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose) {
if (!UseG1GC) return Flag::SUCCESS;
if (value > G1MaxNewSizePercent) {
CommandLineError::print(verbose,
"G1NewSizePercent (" UINTX_FORMAT ") must be "
@ -345,8 +178,6 @@ Flag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose) {
}
Flag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose) {
if (!UseG1GC) return Flag::SUCCESS;
if (value < G1NewSizePercent) {
CommandLineError::print(verbose,
"G1MaxNewSizePercent (" UINTX_FORMAT ") must be "
@ -357,56 +188,15 @@ Flag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose) {
return Flag::SUCCESS;
}
}
#endif // INCLUDE_ALL_GCS
Flag::Error ParGCStridesPerThreadConstraintFunc(uintx value, bool verbose) {
#if INCLUDE_ALL_GCS
if (UseConcMarkSweepGC && (value > ((uintx)max_jint / (uintx)ParallelGCThreads))) {
CommandLineError::print(verbose,
"ParGCStridesPerThread (" UINTX_FORMAT ") must be "
"less than or equal to ergonomic maximum (" UINTX_FORMAT ")\n",
value, ((uintx)max_jint / (uintx)ParallelGCThreads));
return Flag::VIOLATES_CONSTRAINT;
}
#endif
return Flag::SUCCESS;
}
Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
#if INCLUDE_ALL_GCS
if (UseConcMarkSweepGC) {
if (value > CMSOldPLABMax) {
CommandLineError::print(verbose,
"CMSOldPLABMin (" SIZE_FORMAT ") must be "
"less than or equal to CMSOldPLABMax (" SIZE_FORMAT ")\n",
value, CMSOldPLABMax);
return Flag::VIOLATES_CONSTRAINT;
}
status = MaxPLABSizeBounds("CMSOldPLABMin", value, verbose);
}
#endif
return status;
}
Flag::Error CMSOldPLABMaxConstraintFunc(size_t value, bool verbose) {
Flag::Error status = Flag::SUCCESS;
#if INCLUDE_ALL_GCS
if (UseConcMarkSweepGC) {
status = MaxPLABSizeBounds("CMSOldPLABMax", value, verbose);
}
#endif
return status;
}
Flag::Error MarkStackSizeConstraintFunc(size_t value, bool verbose) {
if (value > MarkStackSizeMax) {
if (value > CMSOldPLABMax) {
CommandLineError::print(verbose,
"MarkStackSize (" SIZE_FORMAT ") must be "
"less than or equal to MarkStackSizeMax (" SIZE_FORMAT ")\n",
value, MarkStackSizeMax);
"CMSOldPLABMin (" SIZE_FORMAT ") must be "
"less than or equal to CMSOldPLABMax (" SIZE_FORMAT ")\n",
value, CMSOldPLABMax);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
@ -414,212 +204,23 @@ Flag::Error MarkStackSizeConstraintFunc(size_t value, bool verbose) {
}
Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose) {
#if INCLUDE_ALL_GCS
if (UseConcMarkSweepGC && (value <= CMSPrecleanNumerator)) {
if (value <= CMSPrecleanNumerator) {
CommandLineError::print(verbose,
"CMSPrecleanDenominator (" UINTX_FORMAT ") must be "
"strickly greater than CMSPrecleanNumerator (" UINTX_FORMAT ")\n",
value, CMSPrecleanNumerator);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
#endif
return Flag::SUCCESS;
}
Flag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose) {
#if INCLUDE_ALL_GCS
if (UseConcMarkSweepGC && (value >= CMSPrecleanDenominator)) {
if (value > (CMSPrecleanDenominator - 1)) {
CommandLineError::print(verbose,
"CMSPrecleanNumerator (" UINTX_FORMAT ") must be "
"less than CMSPrecleanDenominator (" UINTX_FORMAT ")\n",
value, CMSPrecleanDenominator);
return Flag::VIOLATES_CONSTRAINT;
}
#endif
return Flag::SUCCESS;
}
Flag::Error CMSWorkQueueDrainThresholdConstraintFunc(uintx value, bool verbose) {
#if INCLUDE_ALL_GCS
if (UseConcMarkSweepGC) {
return ParallelGCThreadsAndCMSWorkQueueDrainThreshold(ParallelGCThreads, value, verbose);
}
#endif
return Flag::SUCCESS;
}
Flag::Error MaxGCPauseMillisConstraintFunc(uintx value, bool verbose) {
#if INCLUDE_ALL_GCS
if (UseG1GC && FLAG_IS_CMDLINE(MaxGCPauseMillis) && (value >= GCPauseIntervalMillis)) {
CommandLineError::print(verbose,
"MaxGCPauseMillis (" UINTX_FORMAT ") must be "
"less than GCPauseIntervalMillis (" UINTX_FORMAT ")\n",
value, GCPauseIntervalMillis);
return Flag::VIOLATES_CONSTRAINT;
}
#endif
return Flag::SUCCESS;
}
Flag::Error GCPauseIntervalMillisConstraintFunc(uintx value, bool verbose) {
#if INCLUDE_ALL_GCS
if (UseG1GC) {
if (FLAG_IS_CMDLINE(GCPauseIntervalMillis)) {
if (value < 1) {
CommandLineError::print(verbose,
"GCPauseIntervalMillis (" UINTX_FORMAT ") must be "
"greater than or equal to 1\n",
value);
return Flag::VIOLATES_CONSTRAINT;
}
if (value <= MaxGCPauseMillis) {
CommandLineError::print(verbose,
"GCPauseIntervalMillis (" UINTX_FORMAT ") must be "
"greater than MaxGCPauseMillis (" UINTX_FORMAT ")\n",
value, MaxGCPauseMillis);
return Flag::VIOLATES_CONSTRAINT;
}
}
}
#endif
return Flag::SUCCESS;
}
Flag::Error InitialBootClassLoaderMetaspaceSizeConstraintFunc(size_t value, bool verbose) {
size_t aligned_max = (size_t)align_size_down(max_uintx/2, Metaspace::reserve_alignment_words());
if (value > aligned_max) {
CommandLineError::print(verbose,
"InitialBootClassLoaderMetaspaceSize (" SIZE_FORMAT ") must be "
"less than or equal to aligned maximum value (" SIZE_FORMAT ")\n",
value, aligned_max);
return Flag::VIOLATES_CONSTRAINT;
}
return Flag::SUCCESS;
}
static Flag::Error MaxSizeForHeapAlignment(const char* name, size_t value, bool verbose) {
// For G1 GC, we don't know until G1CollectorPolicy is created.
size_t heap_alignment;
#if INCLUDE_ALL_GCS
if (UseG1GC) {
heap_alignment = HeapRegionBounds::max_size();
} else
#endif
{
heap_alignment = CollectorPolicy::compute_heap_alignment();
}
// Not to overflow 'align_size_up(value, _heap_alignment) used from CollectorPolicy::initialize_flags()'.
size_t aligned_max = ((max_uintx - heap_alignment) & ~(heap_alignment-1));
if (value > aligned_max) {
CommandLineError::print(verbose,
"%s (" SIZE_FORMAT ") must be "
"less than or equal to aligned maximum value (" SIZE_FORMAT ")\n",
name, value, aligned_max);
return Flag::VIOLATES_CONSTRAINT;
}
return Flag::SUCCESS;
}
Flag::Error InitialHeapSizeConstraintFunc(size_t value, bool verbose) {
return MaxSizeForHeapAlignment("InitialHeapSize", value, verbose);
}
Flag::Error MaxHeapSizeConstraintFunc(size_t value, bool verbose) {
Flag::Error status = MaxSizeForHeapAlignment("MaxHeapSize", value, verbose);
if (status == Flag::SUCCESS) {
status = CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(value, SoftRefLRUPolicyMSPerMB, verbose);
}
return status;
}
Flag::Error NewSizeConstraintFunc(size_t value, bool verbose) {
#ifdef _LP64
#if INCLUDE_ALL_GCS
// Overflow would happen for uint type variable of YoungGenSizer::_min_desired_young_length
// when the value to be assigned exceeds uint range.
// i.e. result of '(uint)(NewSize / region size(1~32MB))'
// So maximum of NewSize should be 'max_juint * 1M'
if (UseG1GC && (value > (max_juint * 1 * M))) {
CommandLineError::print(verbose,
"NewSize (" SIZE_FORMAT ") must be less than ergonomic maximum value\n",
value);
return Flag::VIOLATES_CONSTRAINT;
}
#endif // INCLUDE_ALL_GCS
#endif // _LP64
return Flag::SUCCESS;
}
Flag::Error MinTLABSizeConstraintFunc(size_t value, bool verbose) {
// At least, alignment reserve area is needed.
if (value < ThreadLocalAllocBuffer::alignment_reserve_in_bytes()) {
CommandLineError::print(verbose,
"MinTLABSize (" SIZE_FORMAT ") must be "
"greater than or equal to reserved area in TLAB (" SIZE_FORMAT ")\n",
value, ThreadLocalAllocBuffer::alignment_reserve_in_bytes());
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
}
Flag::Error TLABSizeConstraintFunc(size_t value, bool verbose) {
// Skip for default value of zero which means set ergonomically.
if (FLAG_IS_CMDLINE(TLABSize)) {
if (value < MinTLABSize) {
CommandLineError::print(verbose,
"TLABSize (" SIZE_FORMAT ") must be "
"greater than or equal to MinTLABSize (" SIZE_FORMAT ")\n",
value, MinTLABSize);
return Flag::VIOLATES_CONSTRAINT;
}
if (value > (ThreadLocalAllocBuffer::max_size() * HeapWordSize)) {
CommandLineError::print(verbose,
"TLABSize (" SIZE_FORMAT ") must be "
"less than or equal to ergonomic TLAB maximum size (" SIZE_FORMAT ")\n",
value, (ThreadLocalAllocBuffer::max_size() * HeapWordSize));
return Flag::VIOLATES_CONSTRAINT;
}
}
return Flag::SUCCESS;
}
Flag::Error SurvivorRatioConstraintFunc(uintx value, bool verbose) {
if (FLAG_IS_CMDLINE(SurvivorRatio) &&
(value > (MaxHeapSize / Universe::heap()->collector_policy()->space_alignment()))) {
CommandLineError::print(verbose,
"SurvivorRatio (" UINTX_FORMAT ") must be "
"less than or equal to ergonomic SurvivorRatio maximum (" SIZE_FORMAT ")\n",
value,
(MaxHeapSize / Universe::heap()->collector_policy()->space_alignment()));
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
}
Flag::Error MetaspaceSizeConstraintFunc(size_t value, bool verbose) {
if (value > MaxMetaspaceSize) {
CommandLineError::print(verbose,
"MetaspaceSize (" SIZE_FORMAT ") must be "
"less than or equal to MaxMetaspaceSize (" SIZE_FORMAT ")\n",
value, MaxMetaspaceSize);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
}
Flag::Error MaxMetaspaceSizeConstraintFunc(size_t value, bool verbose) {
if (value < MetaspaceSize) {
CommandLineError::print(verbose,
"MaxMetaspaceSize (" SIZE_FORMAT ") must be "
"greater than or equal to MetaspaceSize (" SIZE_FORMAT ")\n",
value, MaxMetaspaceSize);
"less than or equal to CMSPrecleanDenominator - 1 (" UINTX_FORMAT ")\n",
value, CMSPrecleanDenominator - 1);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;

28
hotspot/src/share/vm/runtime/commandLineFlagConstraintsGC.hpp
View File

@ -34,45 +34,27 @@
* an appropriate error value.
*/
Flag::Error ParallelGCThreadsConstraintFunc(uint value, bool verbose);
Flag::Error ConcGCThreadsConstraintFunc(uint value, bool verbose);
Flag::Error YoungPLABSizeConstraintFunc(size_t value, bool verbose);
Flag::Error OldPLABSizeConstraintFunc(size_t value, bool verbose);
Flag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose);
Flag::Error MaxHeapFreeRatioConstraintFunc(uintx value, bool verbose);
Flag::Error SoftRefLRUPolicyMSPerMBConstraintFunc(intx value, bool verbose);
Flag::Error MinMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose);
Flag::Error MaxMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose);
Flag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose);
Flag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose);
#if INCLUDE_ALL_GCS
Flag::Error G1RSetRegionEntriesConstraintFunc(intx value, bool verbose);
Flag::Error G1RSetSparseRegionEntriesConstraintFunc(intx value, bool verbose);
Flag::Error G1YoungSurvRateNumRegionsSummaryConstraintFunc(intx value, bool verbose);
Flag::Error G1HeapRegionSizeConstraintFunc(size_t value, bool verbose);
Flag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose);
Flag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose);
#endif // INCLUDE_ALL_GCS
Flag::Error ParGCStridesPerThreadConstraintFunc(uintx value, bool verbose);
Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose);
Flag::Error CMSOldPLABMaxConstraintFunc(size_t value, bool verbose);
Flag::Error MarkStackSizeConstraintFunc(size_t value, bool verbose);
Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose);
Flag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose);
Flag::Error CMSWorkQueueDrainThresholdConstraintFunc(uintx value, bool verbose);
Flag::Error MaxGCPauseMillisConstraintFunc(uintx value, bool verbose);
Flag::Error GCPauseIntervalMillisConstraintFunc(uintx value, bool verbose);
Flag::Error InitialBootClassLoaderMetaspaceSizeConstraintFunc(size_t value, bool verbose);
Flag::Error InitialHeapSizeConstraintFunc(size_t value, bool verbose);
Flag::Error MaxHeapSizeConstraintFunc(size_t value, bool verbose);
Flag::Error NewSizeConstraintFunc(size_t value, bool verbose);
Flag::Error MinTLABSizeConstraintFunc(size_t value, bool verbose);
Flag::Error TLABSizeConstraintFunc(size_t value, bool verbose);
Flag::Error SurvivorRatioConstraintFunc(uintx value, bool verbose);
Flag::Error MetaspaceSizeConstraintFunc(size_t value, bool verbose);
Flag::Error MaxMetaspaceSizeConstraintFunc(size_t value, bool verbose);
Flag::Error SurvivorAlignmentInBytesConstraintFunc(intx value, bool verbose);
#endif /* SHARE_VM_RUNTIME_COMMANDLINEFLAGCONSTRAINTSGC_HPP */

2
hotspot/src/share/vm/runtime/commandLineFlagRangeList.cpp
View File

@ -278,7 +278,7 @@ void emit_range_double(const char* name, double min, double max) {
// Generate func argument to pass into emit_range_xxx functions
#define EMIT_RANGE_CHECK(a, b) , a, b
#define INITIAL_RANGES_SIZE 165
#define INITIAL_RANGES_SIZE 128
GrowableArray<CommandLineFlagRange*>* CommandLineFlagRangeList::_ranges = NULL;
// Check the ranges of all flags that have them

74
hotspot/src/share/vm/runtime/globals.hpp
View File

@ -26,7 +26,6 @@
#define SHARE_VM_RUNTIME_GLOBALS_HPP
#include "utilities/debug.hpp"
#include <float.h> // for DBL_MAX
// use this for flags that are true per default in the tiered build
// but false in non-tiered builds, and vice versa
@ -1548,7 +1547,6 @@ public:
\
product(uint, ParallelGCThreads, 0, \
"Number of parallel threads parallel gc will use") \
constraint(ParallelGCThreadsConstraintFunc,AfterErgo) \
\
diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \
"Use semaphore synchronization for the GC Threads, " \
@ -1580,7 +1578,14 @@ public:
\
product(uint, ConcGCThreads, 0, \
"Number of threads concurrent gc will use") \
constraint(ConcGCThreadsConstraintFunc,AfterErgo) \
\
product(size_t, YoungPLABSize, 4096, \
"Size of young gen promotion LAB's (in HeapWords)") \
constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \
\
product(size_t, OldPLABSize, 1024, \
"Size of old gen promotion LAB's (in HeapWords), or Number \
of blocks to attempt to claim when refilling CMS LAB's") \
\
product(uintx, GCTaskTimeStampEntries, 200, \
"Number of time stamp entries per gc worker thread") \
@ -1688,7 +1693,6 @@ public:
"The number of strides per worker thread that we divide up the " \
"card table scanning work into") \
range(1, max_uintx) \
constraint(ParGCStridesPerThreadConstraintFunc,AfterErgo) \
\
diagnostic(intx, ParGCCardsPerStrideChunk, 256, \
"The number of cards in each chunk of the parallel chunks used " \
@ -1711,13 +1715,12 @@ public:
"Maximum size of CMS gen promotion LAB caches per worker " \
"per block size") \
range(1, max_uintx) \
constraint(CMSOldPLABMaxConstraintFunc,AfterMemoryInit) \
\
product(size_t, CMSOldPLABMin, 16, \
"Minimum size of CMS gen promotion LAB caches per worker " \
"per block size") \
range(1, max_uintx) \
constraint(CMSOldPLABMinConstraintFunc,AfterMemoryInit) \
constraint(CMSOldPLABMinConstraintFunc,AfterErgo) \
\
product(uintx, CMSOldPLABNumRefills, 4, \
"Nominal number of refills of CMS gen promotion LAB cache " \
@ -1776,29 +1779,24 @@ public:
product(double, FLSLargestBlockCoalesceProximity, 0.99, \
"CMS: the smaller the percentage the greater the coalescing " \
"force") \
range(0.0, 1.0) \
\
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") \
range(0.0, DBL_MAX) \
\
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") \
range(0.0, DBL_MAX) \
\
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") \
range(0.0, DBL_MAX) \
\
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") \
range(0.0, DBL_MAX) \
\
product(bool, CMSExtrapolateSweep, false, \
"CMS: cushion for block demand during sweep") \
@ -1826,11 +1824,9 @@ public:
\
develop(intx, CMSDictionaryChoice, 0, \
"Use BinaryTreeDictionary as default in the CMS generation") \
range(0, 2) \
\
product(uintx, CMSIndexedFreeListReplenish, 4, \
"Replenish an indexed free list with this number of chunks") \
range(1, max_uintx) \
\
product(bool, CMSReplenishIntermediate, true, \
"Replenish all intermediate free-list caches") \
@ -1845,15 +1841,14 @@ public:
develop(bool, CMSOverflowEarlyRestoration, false, \
"Restore preserved marks early") \
\
product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
"Size of marking stack") \
\
/* where does the range max value of (max_jint - 1) come from? */ \
product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
"Maximum size of marking stack") \
range(1, (max_jint - 1)) \
\
product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
"Size of marking stack") \
constraint(MarkStackSizeConstraintFunc,AfterErgo) \
\
notproduct(bool, CMSMarkStackOverflowALot, false, \
"Simulate frequent marking stack / work queue overflow") \
\
@ -1866,7 +1861,6 @@ public:
\
product(intx, CMSMaxAbortablePrecleanTime, 5000, \
"Maximum time in abortable preclean (in milliseconds)") \
range(0, max_intx) \
\
product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
"Nominal minimum work per abortable preclean iteration") \
@ -1874,7 +1868,6 @@ public:
manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
"Time that we sleep between iterations when not given " \
"enough work per iteration") \
range(0, max_intx) \
\
product(size_t, CMSRescanMultiple, 32, \
"Size (in cards) of CMS parallel rescan task") \
@ -1981,8 +1974,6 @@ public:
\
product(uintx, CMSWorkQueueDrainThreshold, 10, \
"Don't drain below this size per parallel worker/thief") \
range(0, max_juint) \
constraint(CMSWorkQueueDrainThresholdConstraintFunc,AfterErgo) \
\
manageable(intx, CMSWaitDuration, 2000, \
"Time in milliseconds that CMS thread waits for young GC") \
@ -2239,11 +2230,9 @@ public:
\
develop(intx, PSAdaptiveSizePolicyResizeVirtualSpaceAlot, -1, \
"Resize the virtual spaces of the young or old generations") \
range(-1, 1) \
\
product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
"Policy for changing generation size for throughput goals") \
range(0, 1) \
\
develop(bool, PSAdjustTenuredGenForMinorPause, false, \
"Adjust tenured generation to achieve a minor pause goal") \
@ -2315,12 +2304,9 @@ public:
product(uintx, MaxGCPauseMillis, max_uintx, \
"Adaptive size policy maximum GC pause time goal in millisecond, "\
"or (G1 Only) the maximum GC time per MMU time slice") \
range(1, max_uintx) \
constraint(MaxGCPauseMillisConstraintFunc,AfterErgo) \
\
product(uintx, GCPauseIntervalMillis, 0, \
"Time slice for MMU specification") \
constraint(GCPauseIntervalMillisConstraintFunc,AfterErgo) \
\
product(uintx, MaxGCMinorPauseMillis, max_uintx, \
"Adaptive size policy maximum GC minor pause time goal " \
@ -2341,7 +2327,6 @@ public:
\
product(uintx, MinSurvivorRatio, 3, \
"Minimum ratio of young generation/survivor space size") \
range(3, max_uintx) \
\
product(uintx, InitialSurvivorRatio, 8, \
"Initial ratio of young generation/survivor space size") \
@ -2365,7 +2350,6 @@ public:
\
develop(uintx, AdaptiveSizePolicyGCTimeLimitThreshold, 5, \
"Number of consecutive collections before gc time limit fires") \
range(1, max_uintx) \
\
product(bool, PrintAdaptiveSizePolicy, false, \
"Print information about AdaptiveSizePolicy") \
@ -2465,7 +2449,6 @@ public:
develop(intx, ConcGCYieldTimeout, 0, \
"If non-zero, assert that GC threads yield within this " \
"number of milliseconds") \
range(0, max_intx) \
\
product(bool, PrintReferenceGC, false, \
"Print times spent handling reference objects during GC " \
@ -2504,8 +2487,6 @@ public:
product(size_t, InitialBootClassLoaderMetaspaceSize, \
NOT_LP64(2200*K) LP64_ONLY(4*M), \
"Initial size of the boot class loader data metaspace") \
range(BytesPerWord, max_uintx) \
constraint(InitialBootClassLoaderMetaspaceSizeConstraintFunc, AfterErgo)\
\
product(bool, TraceYoungGenTime, false, \
"Trace accumulated time for young collection") \
@ -2582,7 +2563,6 @@ public:
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") \
range(0.0, 100.0) \
\
/* GC log rotation setting */ \
\
@ -3293,19 +3273,15 @@ public:
/* gc parameters */ \
product(size_t, InitialHeapSize, 0, \
"Initial heap size (in bytes); zero means use ergonomics") \
range(0, max_uintx) \
constraint(InitialHeapSizeConstraintFunc,AfterErgo) \
\
product(size_t, MaxHeapSize, ScaleForWordSize(96*M), \
"Maximum heap size (in bytes)") \
constraint(MaxHeapSizeConstraintFunc,AfterErgo) \
\
product(size_t, OldSize, ScaleForWordSize(4*M), \
"Initial tenured generation size (in bytes)") \
\
product(size_t, NewSize, ScaleForWordSize(1*M), \
"Initial new generation size (in bytes)") \
constraint(NewSizeConstraintFunc,AfterErgo) \
\
product(size_t, MaxNewSize, max_uintx, \
"Maximum new generation size (in bytes), max_uintx means set " \
@ -3315,23 +3291,12 @@ public:
"Maximum size in bytes of objects allocated in DefNew " \
"generation; zero means no maximum") \
\
product(size_t, TLABSize, 0, \
"Starting TLAB size (in bytes); zero means set ergonomically") \
\
product(size_t, MinTLABSize, 2*K, \
"Minimum allowed TLAB size (in bytes)") \
range(1, max_uintx) \
constraint(MinTLABSizeConstraintFunc,AfterMemoryInit) \
\
product(size_t, TLABSize, 0, \
"Starting TLAB size (in bytes); zero means set ergonomically") \
constraint(TLABSizeConstraintFunc,AfterMemoryInit) \
\
product(size_t, YoungPLABSize, 4096, \
"Size of young gen promotion LAB's (in HeapWords)") \
constraint(YoungPLABSizeConstraintFunc,AfterMemoryInit) \
\
product(size_t, OldPLABSize, 1024, \
"Size of old gen promotion LAB's (in HeapWords), or Number " \
"of blocks to attempt to claim when refilling CMS LAB's") \
constraint(OldPLABSizeConstraintFunc,AfterMemoryInit) \
\
product(uintx, TLABAllocationWeight, 35, \
"Allocation averaging weight") \
@ -3352,12 +3317,9 @@ public:
\
product(uintx, SurvivorRatio, 8, \
"Ratio of eden/survivor space size") \
range(1, max_uintx-2) \
constraint(SurvivorRatioConstraintFunc,AfterMemoryInit) \
\
product(uintx, NewRatio, 2, \
"Ratio of old/new generation sizes") \
range(0, max_uintx-1) \
\
product_pd(size_t, NewSizeThreadIncrease, \
"Additional size added to desired new generation size per " \
@ -3365,11 +3327,9 @@ public:
\
product_pd(size_t, MetaspaceSize, \
"Initial size of Metaspaces (in bytes)") \
constraint(MetaspaceSizeConstraintFunc,AfterErgo) \
\
product(size_t, MaxMetaspaceSize, max_uintx, \
"Maximum size of Metaspaces (in bytes)") \
constraint(MaxMetaspaceSizeConstraintFunc,AfterErgo) \
\
product(size_t, CompressedClassSpaceSize, 1*G, \
"Maximum size of class area in Metaspace when compressed " \
@ -3392,8 +3352,6 @@ public:
\
product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
"Number of milliseconds per MB of free space in the heap") \
range(0, max_intx) \
constraint(SoftRefLRUPolicyMSPerMBConstraintFunc,AfterMemoryInit) \
\
product(size_t, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
"The minimum change in heap space due to GC (in bytes)") \
@ -3425,7 +3383,6 @@ public:
\
diagnostic(intx, VerifyGCLevel, 0, \
"Generation level at which to start +VerifyBefore/AfterGC") \
range(0, 1) \
\
product(uintx, MaxTenuringThreshold, 15, \
"Maximum value for tenuring threshold") \
@ -3484,7 +3441,6 @@ public:
"before changing safepoint polling page to RO ") \
\
product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
range(0, max_intx) \
\
product(bool, PSChunkLargeArrays, true, \
"Process large arrays in chunks") \

110
hotspot/test/gc/arguments/TestG1ConcMarkStepDurationMillis.java
View File

@ -1,110 +0,0 @@
/*
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test TestG1ConcMarkStepDurationMillis
* @key gc
* @requires vm.gc=="null" | vm.gc=="G1"
* @summary Tests argument processing for double type flag, G1ConcMarkStepDurationMillis
* @library /testlibrary
* @modules java.base/sun.misc
* java.management
*/
import jdk.test.lib.*;
import java.util.*;
import java.util.regex.*;
public class TestG1ConcMarkStepDurationMillis {
static final int PASS = 0;
static final int FAIL_IMPROPER_VALUE = 1;
static final int FAIL_OUT_RANGE = 2;
static final String DOUBLE_1 = "1.0";
static final String DOUBLE_MAX = "1.79e+308";
static final String DOUBLE_NEG_EXP = "1.0e-30";
static final String NEG_DOUBLE_1 = "-1.0";
static final String DOUBLE_INF = "1.79e+309";
static final String NEG_DOUBLE_INF = "-1.79e+309";
static final String DOUBLE_NAN = "abe+309";
static final String WRONG_DOUBLE_1 = "1.79e+308e";
static final String WRONG_DOUBLE_2 = "1.79ee+308";
public static void main(String args[]) throws Exception {
// Pass cases
runG1ConcMarkStepDurationMillisTest(DOUBLE_1, PASS);
runG1ConcMarkStepDurationMillisTest(DOUBLE_MAX, PASS);
// Fail cases: out of range
runG1ConcMarkStepDurationMillisTest(DOUBLE_NEG_EXP, FAIL_OUT_RANGE);
runG1ConcMarkStepDurationMillisTest(NEG_DOUBLE_1, FAIL_OUT_RANGE);
// Fail cases: not double
runG1ConcMarkStepDurationMillisTest(DOUBLE_INF, FAIL_IMPROPER_VALUE);
runG1ConcMarkStepDurationMillisTest(NEG_DOUBLE_INF, FAIL_IMPROPER_VALUE);
runG1ConcMarkStepDurationMillisTest(DOUBLE_NAN, FAIL_IMPROPER_VALUE);
runG1ConcMarkStepDurationMillisTest(WRONG_DOUBLE_1, FAIL_IMPROPER_VALUE);
runG1ConcMarkStepDurationMillisTest(WRONG_DOUBLE_2, FAIL_IMPROPER_VALUE);
}
private static void runG1ConcMarkStepDurationMillisTest(String expectedValue, int expectedResult) throws Exception {
List<String> vmOpts = new ArrayList<>();
Collections.addAll(vmOpts, "-XX:+UseG1GC", "-XX:G1ConcMarkStepDurationMillis="+expectedValue, "-XX:+PrintFlagsFinal", "-version");
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(vmOpts.toArray(new String[vmOpts.size()]));
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(expectedResult == PASS ? 0 : 1);
String stdout = output.getStdout();
if (expectedResult == PASS) {
checkG1ConcMarkStepDurationMillisConsistency(stdout, expectedValue);
} else if (expectedResult == FAIL_IMPROPER_VALUE) {
output.shouldContain("Improperly specified VM option");
} else if (expectedResult == FAIL_OUT_RANGE) {
output.shouldContain("outside the allowed range");
}
}
private static void checkG1ConcMarkStepDurationMillisConsistency(String output, String expectedValue) {
double actualValue = getDoubleValue("G1ConcMarkStepDurationMillis", output);
if (Double.parseDouble(expectedValue) != actualValue) {
throw new RuntimeException(
"Actual G1ConcMarkStepDurationMillis(" + Double.toString(actualValue)
+ ") is not equal to expected value(" + expectedValue + ")");
}
}
public static double getDoubleValue(String flag, String where) {
Matcher m = Pattern.compile(flag + "\\s+:?=\\s+\\d+").matcher(where);
if (!m.find()) {
throw new RuntimeException("Could not find value for flag " + flag + " in output string");
}
String match = m.group();
return Double.parseDouble(match.substring(match.lastIndexOf(" ") + 1, match.length()));
}
}

64
hotspot/test/gc/arguments/TestG1HeapRegionSize.java
View File

@ -25,60 +25,42 @@
* @test TestG1HeapRegionSize
* @key gc
* @bug 8021879
* @requires vm.gc=="null" | vm.gc=="G1"
* @summary Verify that the flag G1HeapRegionSize is updated properly
* @modules java.management/sun.management
* @library /testlibrary
* @run main TestG1HeapRegionSize
* @run main/othervm -Xmx64m TestG1HeapRegionSize 1048576
* @run main/othervm -XX:G1HeapRegionSize=2m -Xmx64m TestG1HeapRegionSize 2097152
* @run main/othervm -XX:G1HeapRegionSize=3m -Xmx64m TestG1HeapRegionSize 2097152
* @run main/othervm -XX:G1HeapRegionSize=64m -Xmx256m TestG1HeapRegionSize 33554432
*/
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.Arrays;
import jdk.test.lib.*;
import com.sun.management.HotSpotDiagnosticMXBean;
import com.sun.management.VMOption;
import java.lang.management.ManagementFactory;
public class TestG1HeapRegionSize {
private static void checkG1HeapRegionSize(String[] flags, int expectedValue, int exitValue) throws Exception {
ArrayList<String> flagList = new ArrayList<String>();
flagList.addAll(Arrays.asList(flags));
flagList.add("-XX:+UseG1GC");
flagList.add("-XX:+PrintFlagsFinal");
flagList.add("-version");
public static void main(String[] args) {
HotSpotDiagnosticMXBean diagnostic =
ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class);
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(flagList.toArray(new String[0]));
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(exitValue);
String expectedValue = getExpectedValue(args);
VMOption option = diagnostic.getVMOption("UseG1GC");
if (option.getValue().equals("false")) {
System.out.println("Skipping this test. It is only a G1 test.");
return;
}
if (exitValue == 0) {
String stdout = output.getStdout();
//System.out.println(stdout);
int flagValue = getFlagValue("G1HeapRegionSize", stdout);
if (flagValue != expectedValue) {
throw new RuntimeException("Wrong value for G1HeapRegionSize. Expected " + expectedValue + " but got " + flagValue);
}
option = diagnostic.getVMOption("G1HeapRegionSize");
if (!expectedValue.equals(option.getValue())) {
throw new RuntimeException("Wrong value for G1HeapRegionSize. Expected " + expectedValue + " but got " + option.getValue());
}
}
private static int getFlagValue(String flag, String where) {
Matcher m = Pattern.compile(flag + "\\s+:?=\\s+\\d+").matcher(where);
if (!m.find()) {
throw new RuntimeException("Could not find value for flag " + flag + " in output string");
private static String getExpectedValue(String[] args) {
if (args.length != 1) {
throw new RuntimeException("Wrong number of arguments. Expected 1 but got " + args.length);
}
String match = m.group();
return Integer.parseInt(match.substring(match.lastIndexOf(" ") + 1, match.length()));
return args[0];
}
public static void main(String args[]) throws Exception {
final int M = 1024 * 1024;
checkG1HeapRegionSize(new String[] { "-Xmx64m" /* default is 1m */ }, 1*M, 0);
checkG1HeapRegionSize(new String[] { "-Xmx64m", "-XX:G1HeapRegionSize=2m" }, 2*M, 0);
checkG1HeapRegionSize(new String[] { "-Xmx64m", "-XX:G1HeapRegionSize=3m" }, 2*M, 0);
checkG1HeapRegionSize(new String[] { "-Xmx256m", "-XX:G1HeapRegionSize=32m" }, 32*M, 0);
checkG1HeapRegionSize(new String[] { "-Xmx256m", "-XX:G1HeapRegionSize=64m" }, 32*M, 1);
}
}

2
hotspot/test/gc/arguments/TestHeapFreeRatio.java
View File

@ -72,7 +72,7 @@ public class TestHeapFreeRatio {
output.shouldHaveExitValue(1);
break;
case COMBINATION_INVALID:
output.shouldContain("must be less than or equal to MaxHeapFreeRatio");
output.shouldContain("must be greater than or equal to MinHeapFreeRatio");
output.shouldContain("Error");
output.shouldHaveExitValue(1);
break;

2
hotspot/test/gc/arguments/TestInitialTenuringThreshold.java
View File

@ -25,7 +25,6 @@
* @test TestInitialTenuringThreshold
* @key gc
* @bug 8014765
* @requires vm.gc=="Parallel"
* @summary Tests argument processing for initial tenuring threshold
* @library /testlibrary
* @modules java.base/sun.misc
@ -40,7 +39,6 @@ public class TestInitialTenuringThreshold {
public static void runWithThresholds(int initial, int max, boolean shouldfail) throws Exception {
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
"-XX:+UseParallelGC",
"-XX:InitialTenuringThreshold=" + String.valueOf(initial),
"-XX:MaxTenuringThreshold=" + String.valueOf(max),
"-version"

3
hotspot/test/gc/arguments/TestObjectTenuringFlags.java
View File

@ -25,7 +25,6 @@
* @test TestObjectTenuringFlags
* @key gc
* @bug 6521376
* @requires vm.gc=="Parallel"
* @summary Tests argument processing for NeverTenure, AlwaysTenure,
* and MaxTenuringThreshold
* @library /testlibrary
@ -158,7 +157,7 @@ public class TestObjectTenuringFlags {
if (tenuringFlags.length > 0) {
Collections.addAll(vmOpts, tenuringFlags);
}
Collections.addAll(vmOpts, "-XX:+UseParallelGC", "-XX:+PrintFlagsFinal", "-version");
Collections.addAll(vmOpts, "-XX:+PrintFlagsFinal", "-version");
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(vmOpts.toArray(new String[vmOpts.size()]));
OutputAnalyzer output = new OutputAnalyzer(pb.start());