jdk-sandbox: comparison hotspot/src/share/vm/runtime/arguments.cpp

equal deleted inserted replaced

-:a19b9cf9ffa8
+:ea32f6c51d08
 jio_fprintf(defaultStream::error_stream(),
 "The Parallel GC can not be combined with -XX:ParallelGCThreads=0\n");
 vm_exit(1);
 }
+if (UseAdaptiveSizePolicy) {
+// We don't want to limit adaptive heap sizing's freedom to adjust the heap
+// unless the user actually sets these flags.
+if (FLAG_IS_DEFAULT(MinHeapFreeRatio)) {
+FLAG_SET_DEFAULT(MinHeapFreeRatio, 0);
+}
+if (FLAG_IS_DEFAULT(MaxHeapFreeRatio)) {
+FLAG_SET_DEFAULT(MaxHeapFreeRatio, 100);
+}
+}
 // If InitialSurvivorRatio or MinSurvivorRatio were not specified, but the
 // SurvivorRatio has been set, reset their default values to SurvivorRatio +
 // 2.  By doing this we make SurvivorRatio also work for Parallel Scavenger.
 // See CR 6362902 for details.
 name, val, min);
 return false;
 }
 bool Arguments::verify_percentage(uintx value, const char* name) {
-if (value <= 100) {
+if (is_percentage(value)) {
 return true;
 }
 jio_fprintf(defaultStream::error_stream(),
 "%s of " UINTX_FORMAT " is invalid; must be between 0 and 100\n",
 name, value);
 }
 }
 return false;
 }
 return count_p < 2 && count_t < 2;
+}
+bool Arguments::verify_MinHeapFreeRatio(FormatBuffer<80>& err_msg, uintx min_heap_free_ratio) {
+if (!is_percentage(min_heap_free_ratio)) {
+err_msg.print("MinHeapFreeRatio must have a value between 0 and 100");
+return false;
+}
+if (min_heap_free_ratio > MaxHeapFreeRatio) {
+err_msg.print("MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
+"equal to MaxHeapFreeRatio (" UINTX_FORMAT ")", min_heap_free_ratio,
+MaxHeapFreeRatio);
+return false;
+}
+return true;
+}
+bool Arguments::verify_MaxHeapFreeRatio(FormatBuffer<80>& err_msg, uintx max_heap_free_ratio) {
+if (!is_percentage(max_heap_free_ratio)) {
+err_msg.print("MaxHeapFreeRatio must have a value between 0 and 100");
+return false;
+}
+if (max_heap_free_ratio < MinHeapFreeRatio) {
+err_msg.print("MaxHeapFreeRatio (" UINTX_FORMAT ") must be greater than or "
+"equal to MinHeapFreeRatio (" UINTX_FORMAT ")", max_heap_free_ratio,
+MinHeapFreeRatio);
+return false;
+}
+return true;
 }
 // Check consistency of GC selection
 bool Arguments::check_gc_consistency() {
 check_gclog_consistency();
 }
 status = status && verify_interval(AdaptiveSizePolicyWeight, 0, 100,
 "AdaptiveSizePolicyWeight");
 status = status && verify_percentage(ThresholdTolerance, "ThresholdTolerance");
-status = status && verify_percentage(MinHeapFreeRatio, "MinHeapFreeRatio");
-status = status && verify_percentage(MaxHeapFreeRatio, "MaxHeapFreeRatio");
 // Divide by bucket size to prevent a large size from causing rollover when
 // calculating amount of memory needed to be allocated for the String table.
 status = status && verify_interval(StringTableSize, minimumStringTableSize,
 (max_uintx / StringTable::bucket_size()), "StringTable size");
 status = status && verify_interval(SymbolTableSize, minimumSymbolTableSize,
 (max_uintx / SymbolTable::bucket_size()), "SymbolTable size");
-if (MinHeapFreeRatio > MaxHeapFreeRatio) {
+{
-jio_fprintf(defaultStream::error_stream(),
+// Using "else if" below to avoid printing two error messages if min > max.
-"MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
+// This will also prevent us from reporting both min>100 and max>100 at the
-"equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
+// same time, but that is less annoying than printing two identical errors IMHO.
-MinHeapFreeRatio, MaxHeapFreeRatio);
+FormatBuffer<80> err_msg("");
-status = false;
+if (!verify_MinHeapFreeRatio(err_msg, MinHeapFreeRatio)) {
-}
+jio_fprintf(defaultStream::error_stream(), "%s\n", err_msg.buffer());
-// Keeping the heap 100% free is hard ;-) so limit it to 99%.
+status = false;
-MinHeapFreeRatio = MIN2(MinHeapFreeRatio, (uintx) 99);
+} else if (!verify_MaxHeapFreeRatio(err_msg, MaxHeapFreeRatio)) {
+jio_fprintf(defaultStream::error_stream(), "%s\n", err_msg.buffer());
+status = false;
+}
+}
 // Min/MaxMetaspaceFreeRatio
 status = status && verify_percentage(MinMetaspaceFreeRatio, "MinMetaspaceFreeRatio");
 status = status && verify_percentage(MaxMetaspaceFreeRatio, "MaxMetaspaceFreeRatio");
 FLAG_SET_CMDLINE(uintx, MaxHeapSize, (uintx)long_max_heap_size);
 // Xmaxf
 } else if (match_option(option, "-Xmaxf", &tail)) {
 char* err;
 int maxf = (int)(strtod(tail, &err) * 100);
-if (*err != '\0' || maxf < 0 || maxf > 100) {
+if (*err != '\0' || *tail == '\0' || maxf < 0 || maxf > 100) {
 jio_fprintf(defaultStream::error_stream(),
 "Bad max heap free percentage size: %s\n",
 option->optionString);
 return JNI_EINVAL;
 } else {
 }
 // Xminf
 } else if (match_option(option, "-Xminf", &tail)) {
 char* err;
 int minf = (int)(strtod(tail, &err) * 100);
-if (*err != '\0' || minf < 0 || minf > 100) {
+if (*err != '\0' || *tail == '\0' || minf < 0 || minf > 100) {
 jio_fprintf(defaultStream::error_stream(),
 "Bad min heap free percentage size: %s\n",
 option->optionString);
 return JNI_EINVAL;
 } else {
 #if INCLUDE_ALL_GCS
 // Set per-collector flags
 if (UseParallelGC || UseParallelOldGC) {
 set_parallel_gc_flags();
-} else if (UseConcMarkSweepGC) { // should be done before ParNew check below
+} else if (UseConcMarkSweepGC) { // Should be done before ParNew check below
 set_cms_and_parnew_gc_flags();
-} else if (UseParNewGC) {  // skipped if CMS is set above
+} else if (UseParNewGC) {  // Skipped if CMS is set above
 set_parnew_gc_flags();
 } else if (UseG1GC) {
 set_g1_gc_flags();
 }
 check_deprecated_gcs();
 if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) {
 warning("If the number of processors is expected to increase from one, then"
 " you should configure the number of parallel GC threads appropriately"
 " using -XX:ParallelGCThreads=N");
 }
+}
+if (MinHeapFreeRatio == 100) {
+// Keeping the heap 100% free is hard ;-) so limit it to 99%.
+FLAG_SET_ERGO(uintx, MinHeapFreeRatio, 99);
 }
 #else // INCLUDE_ALL_GCS
 assert(verify_serial_gc_flags(), "SerialGC unset");
 #endif // INCLUDE_ALL_GCS

changeset 22555	ea32f6c51d08
parent 22551	9bf46d16dcc6
child 22556	a17351e8c2c2
child 22763	ac261a7c84b3