< prev index next >
src/share/vm/runtime/commandLineFlagConstraintsGC.cpp
Print this page
rev 8851 : [mq]: webrev.00
rev 8852 : [mq]: webrev.01
@@ -43,63 +43,65 @@
#endif // COMPILER1
#ifdef COMPILER2
#include "opto/c2_globals.hpp"
#endif // COMPILER2
-static Flag::Error ParallelGCThreadsAndCMSWorkQueueDrainThreshold(bool verbose) {
+#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 && (ParallelGCThreads > (uint)(max_jint / (uint)CMSWorkQueueDrainThreshold))) {
+ if (UseConcMarkSweepGC && (threads > (uint)(max_jint / (uint)threshold))) {
CommandLineError::print(verbose,
"ParallelGCThreads (" UINT32_FORMAT ") or CMSWorkQueueDrainThreshold ("
UINTX_FORMAT ") is too large\n",
- ParallelGCThreads, CMSWorkQueueDrainThreshold);
+ 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;
}
- // G1, CMS and Parallel GC modes disallows ParallelGCThreads=0
- if ((UseG1GC || UseConcMarkSweepGC || UseParallelGC) && (value == 0)) {
- CommandLineError::print(verbose, "ParallelGCThreads cannot be zero\n");
- 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;
}
-
- return ParallelGCThreadsAndCMSWorkQueueDrainThreshold(verbose);
+ 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;
- } else {
- return Flag::SUCCESS;
}
+#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())) {
@@ -138,24 +140,29 @@
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().
- return MaxPLABSizeBounds("OldPLABSize", value, verbose);
+ status = MaxPLABSizeBounds("OldPLABSize", value, verbose);
} else {
- return MinMaxPLABSizeBounds("OldPLABSize", value, verbose);
+ status = MinMaxPLABSizeBounds("OldPLABSize", value, verbose);
}
+#endif
+ return status;
}
Flag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose) {
if (value > MaxHeapFreeRatio) {
CommandLineError::print(verbose,
@@ -178,25 +185,24 @@
} else {
return Flag::SUCCESS;
}
}
-static Flag::Error CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(bool verbose) {
- if ((SoftRefLRUPolicyMSPerMB > 0) &&
- (MaxHeapSize / M > max_uintx / SoftRefLRUPolicyMSPerMB)) {
+static Flag::Error CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(size_t maxHeap, intx softRef, bool verbose) {
+ if ((softRef > 0) && (maxHeap / M > max_uintx / softRef)) {
CommandLineError::print(verbose,
"MaxHeapSize (" SIZE_FORMAT ") or SoftRefLRUPolicyMSPerMB "
"(" INTX_FORMAT ") is too large\n",
- MaxHeapSize, SoftRefLRUPolicyMSPerMB);
+ maxHeap, softRef);
return Flag::VIOLATES_CONSTRAINT;
} else {
return Flag::SUCCESS;
}
}
Flag::Error SoftRefLRUPolicyMSPerMBConstraintFunc(intx value, bool verbose) {
- return CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(verbose);
+ return CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(MaxHeapSize, value, verbose);
}
Flag::Error MinMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) {
if (value > MaxMetaspaceFreeRatio) {
CommandLineError::print(verbose,
@@ -220,36 +226,35 @@
return Flag::SUCCESS;
}
}
Flag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose) {
+#if INCLUDE_ALL_GCS
// InitialTenuringThreshold is only used for ParallelGC.
- if (!UseParallelGC) {
- return Flag::SUCCESS;
- }
-
- if (value > MaxTenuringThreshold) {
+ 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;
- } 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)) {
CommandLineError::print(verbose,
"MaxTenuringThreshold (" UINTX_FORMAT ") must be "
"greater than or equal to InitialTenuringThreshold (" UINTX_FORMAT ")\n",
value, InitialTenuringThreshold);
return Flag::VIOLATES_CONSTRAINT;
}
+#endif
// MaxTenuringThreshold=0 means NeverTenure=false && AlwaysTenure=true
if ((value == 0) && (NeverTenure || !AlwaysTenure)) {
CommandLineError::print(verbose,
"MaxTenuringThreshold (0) should match to NeverTenure=false "
@@ -352,94 +357,103 @@
}
}
#endif // INCLUDE_ALL_GCS
Flag::Error ParGCStridesPerThreadConstraintFunc(uintx value, bool verbose) {
- if (!UseConcMarkSweepGC) return Flag::SUCCESS;
-
- if (value > max_jint / ParallelGCThreads) {
+#if INCLUDE_ALL_GCS
+ if (UseConcMarkSweepGC && (value > max_jint / ParallelGCThreads)) {
CommandLineError::print(verbose,
"ParGCStridesPerThread (" UINTX_FORMAT ") must be "
"less than or equal to ergonomic maximum (" INT32_FORMAT ")\n",
value, max_jint / ParallelGCThreads);
return Flag::VIOLATES_CONSTRAINT;
- } else {
- return Flag::SUCCESS;
}
+#endif
+ return Flag::SUCCESS;
}
Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose) {
- if (!UseConcMarkSweepGC) return Flag::SUCCESS;
+ 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;
}
-
- return MaxPLABSizeBounds("CMSOldPLABMin", value, verbose);
+ status = MaxPLABSizeBounds("CMSOldPLABMin", value, verbose);
+ }
+#endif
+ return status;
}
Flag::Error CMSOldPLABMaxConstraintFunc(size_t value, bool verbose) {
- if (!UseConcMarkSweepGC) return Flag::SUCCESS;
+ Flag::Error status = Flag::SUCCESS;
- return MaxPLABSizeBounds("CMSOldPLABMax", value, verbose);
+#if INCLUDE_ALL_GCS
+ if (UseConcMarkSweepGC) {
+ status = MaxPLABSizeBounds("CMSOldPLABMax", value, verbose);
+ }
+#endif
+ return status;
}
Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose) {
- if (!UseConcMarkSweepGC) return Flag::SUCCESS;
-
- if (value <= CMSPrecleanNumerator) {
+#if INCLUDE_ALL_GCS
+ if (UseConcMarkSweepGC && (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 (!UseConcMarkSweepGC) return Flag::SUCCESS;
-
- if (value >= CMSPrecleanDenominator) {
+#if INCLUDE_ALL_GCS
+ if (UseConcMarkSweepGC && (value >= CMSPrecleanDenominator)) {
CommandLineError::print(verbose,
"CMSPrecleanNumerator (" UINTX_FORMAT ") must be "
"less than CMSPrecleanDenominator (" UINTX_FORMAT ")\n",
value, CMSPrecleanDenominator);
return Flag::VIOLATES_CONSTRAINT;
- } else {
- return Flag::SUCCESS;
}
+#endif
+ return Flag::SUCCESS;
}
Flag::Error CMSWorkQueueDrainThresholdConstraintFunc(uintx value, bool verbose) {
- if (!UseConcMarkSweepGC) return Flag::SUCCESS;
-
- return ParallelGCThreadsAndCMSWorkQueueDrainThreshold(verbose);
+#if INCLUDE_ALL_GCS
+ if (UseConcMarkSweepGC) {
+ return ParallelGCThreadsAndCMSWorkQueueDrainThreshold(ParallelGCThreads, value, verbose);
+ }
+#endif
+ return Flag::SUCCESS;
}
Flag::Error MaxGCPauseMillisConstraintFunc(uintx value, bool verbose) {
- if (!UseG1GC) return Flag::SUCCESS;
-
- if (FLAG_IS_CMDLINE(MaxGCPauseMillis) && (value >= GCPauseIntervalMillis)) {
+#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;
- } else {
- return Flag::SUCCESS;
}
+#endif
+
+ return Flag::SUCCESS;
}
Flag::Error GCPauseIntervalMillisConstraintFunc(uintx value, bool verbose) {
- if (!UseG1GC) return Flag::SUCCESS;
-
+#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",
@@ -452,11 +466,12 @@
"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());
@@ -501,11 +516,11 @@
Flag::Error MaxHeapSizeConstraintFunc(size_t value, bool verbose) {
Flag::Error status = MaxSizeForHeapAlignment("MaxHeapSize", value, verbose);
if (status == Flag::SUCCESS) {
- status = CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(verbose);
+ status = CheckMaxHeapSizeAndSoftRefLRUPolicyMSPerMB(value, SoftRefLRUPolicyMSPerMB, verbose);
}
return status;
}
Flag::Error NewSizeConstraintFunc(size_t value, bool verbose) {
@@ -521,11 +536,10 @@
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.
< prev index next >