graal-compiler: src/share/vm/runtime/arguments.cpp comparison

comparison src/share/vm/runtime/arguments.cpp @ 18058:54bc75c144b0

Merge

author	asaha
date	Thu, 29 May 2014 13:14:25 -0700
parents	fbf689f3752e 78bbf4d43a14
children	ca6d25be853b

comparison

equal deleted inserted replaced

-:1fa005fb28f5
+:54bc75c144b0
 /*
-* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2014, 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.
 #ifdef TARGET_OS_FAMILY_solaris
 # include "os_solaris.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_windows
 # include "os_windows.inline.hpp"
+#endif
+#ifdef TARGET_OS_FAMILY_aix
+# include "os_aix.inline.hpp"
 #endif
 #ifdef TARGET_OS_FAMILY_bsd
 # include "os_bsd.inline.hpp"
 #endif
 #if INCLUDE_ALL_GCS
 { "UseSplitVerifier",              JDK_Version::jdk(8), JDK_Version::jdk(9) },
 { "UseISM",                        JDK_Version::jdk(8), JDK_Version::jdk(9) },
 { "UsePermISM",                    JDK_Version::jdk(8), JDK_Version::jdk(9) },
 { "UseMPSS",                       JDK_Version::jdk(8), JDK_Version::jdk(9) },
 { "UseStringCache",                JDK_Version::jdk(8), JDK_Version::jdk(9) },
+{ "UseOldInlining",                JDK_Version::jdk(9), JDK_Version::jdk(10) },
 #ifdef PRODUCT
 { "DesiredMethodLimit",
 JDK_Version::jdk_update(7, 2), JDK_Version::jdk(8) },
 #endif // PRODUCT
 { NULL, JDK_Version(0), JDK_Version(0) }
 void Arguments::print_jvm_flags_on(outputStream* st) {
 if (_num_jvm_flags > 0) {
 for (int i=0; i < _num_jvm_flags; i++) {
 st->print("%s ", _jvm_flags_array[i]);
 }
-st->print_cr("");
+st->cr();
 }
 }
 void Arguments::print_jvm_args_on(outputStream* st) {
 if (_num_jvm_args > 0) {
 for (int i=0; i < _num_jvm_args; i++) {
 st->print("%s ", _jvm_args_array[i]);
 }
-st->print_cr("");
+st->cr();
 }
 }
 bool Arguments::process_argument(const char* arg,
 jboolean ignore_unrecognized, Flag::Flags origin) {
 arg_len = strlen(argname);
 } else {
 arg_len = equal_sign - argname;
 }
-Flag* found_flag = Flag::find_flag((const char*)argname, arg_len, true);
+Flag* found_flag = Flag::find_flag((const char*)argname, arg_len, true, true);
 if (found_flag != NULL) {
 char locked_message_buf[BUFLEN];
 found_flag->get_locked_message(locked_message_buf, BUFLEN);
 if (strlen(locked_message_buf) == 0) {
 if (found_flag->is_bool() && !has_plus_minus) {
 if (!FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim) || !FLAG_IS_DEFAULT(OldPLABWeight)) {
 CFLS_LAB::modify_initialization(OldPLABSize, OldPLABWeight);
 }
 if (PrintGCDetails && Verbose) {
 tty->print_cr("MarkStackSize: %uk  MarkStackSizeMax: %uk",
-MarkStackSize / K, MarkStackSizeMax / K);
+(unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K));
-tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
+tty->print_cr("ConcGCThreads: %u", (uint) ConcGCThreads);
 }
 }
 #endif // INCLUDE_ALL_GCS
 void set_object_alignment() {
 !FLAG_IS_DEFAULT(MaxGCPauseMillis) &&
 (MaxGCPauseMillis <= AutoGCSelectPauseMillis)) {
 if (PrintGCDetails) {
 // Cannot use gclog_or_tty yet.
 tty->print_cr("Automatic selection of the low pause collector"
-" based on pause goal of %d (ms)", MaxGCPauseMillis);
+" based on pause goal of %d (ms)", (int) MaxGCPauseMillis);
 }
 return true;
 }
 return false;
 }
 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.
 FLAG_SET_DEFAULT(GCTimeRatio, 9);
 }
 if (PrintGCDetails && Verbose) {
 tty->print_cr("MarkStackSize: %uk  MarkStackSizeMax: %uk",
-MarkStackSize / K, MarkStackSizeMax / K);
+(unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K));
-tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
+tty->print_cr("ConcGCThreads: %u", (uint) ConcGCThreads);
 }
 }
 julong Arguments::limit_by_allocatable_memory(julong limit) {
 julong max_allocatable;
 reasonable_max = MAX2(reasonable_max, (julong)InitialHeapSize);
 }
 if (PrintGCDetails && Verbose) {
 // Cannot use gclog_or_tty yet.
-tty->print_cr("  Maximum heap size " SIZE_FORMAT, reasonable_max);
+tty->print_cr("  Maximum heap size " SIZE_FORMAT, (size_t) reasonable_max);
 }
 FLAG_SET_ERGO(uintx, MaxHeapSize, (uintx)reasonable_max);
 }
 // If the minimum or initial heap_size have not been set or requested to be set
 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);
 #endif // INCLUDE_ALL_GCS
 // check if do gclog rotation
 // +UseGCLogFileRotation is a must,
 // no gc log rotation when log file not supplied or
-// NumberOfGCLogFiles is 0, or GCLogFileSize is 0
+// NumberOfGCLogFiles is 0
 void check_gclog_consistency() {
 if (UseGCLogFileRotation) {
-if ((Arguments::gc_log_filename() == NULL) ||
+if ((Arguments::gc_log_filename() == NULL) || (NumberOfGCLogFiles == 0)) {
-(NumberOfGCLogFiles == 0)  ||
-(GCLogFileSize == 0)) {
 jio_fprintf(defaultStream::output_stream(),
-"To enable GC log rotation, use -Xloggc:<filename> -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=<num_of_files> -XX:GCLogFileSize=<num_of_size>[k|K|m|M|g|G]\n"
+"To enable GC log rotation, use -Xloggc:<filename> -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=<num_of_files>\n"
-"where num_of_file > 0 and num_of_size > 0\n"
+"where num_of_file > 0\n"
 "GC log rotation is turned off\n");
 UseGCLogFileRotation = false;
 }
 }
-if (UseGCLogFileRotation && GCLogFileSize < 8*K) {
+if (UseGCLogFileRotation && (GCLogFileSize != 0) && (GCLogFileSize < 8*K)) {
 FLAG_SET_CMDLINE(uintx, GCLogFileSize, 8*K);
 jio_fprintf(defaultStream::output_stream(),
 "GCLogFileSize changed to minimum 8K\n");
 }
 }
 // This function is called for -Xloggc:<filename>, it can be used
 // to check if a given file name(or string) conforms to the following
 }
 }
 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("%s","");
-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");
 "G1ConcMarkStepDurationMillis");
 status = status && verify_interval(G1ConcRSHotCardLimit, 0, max_jubyte,
 "G1ConcRSHotCardLimit");
 status = status && verify_interval(G1ConcRSLogCacheSize, 0, 31,
 "G1ConcRSLogCacheSize");
+status = status && verify_interval(StringDeduplicationAgeThreshold, 1, markOopDesc::max_age,
+"StringDeduplicationAgeThreshold");
 }
 if (UseConcMarkSweepGC) {
 status = status && verify_min_value(CMSOldPLABNumRefills, 1, "CMSOldPLABNumRefills");
 status = status && verify_min_value(CMSOldPLABToleranceFactor, 1, "CMSOldPLABToleranceFactor");
 status = status && verify_min_value(CMSOldPLABMax, 1, "CMSOldPLABMax");
 status = false;
 }
 status &= verify_interval(NmethodSweepFraction, 1, ReservedCodeCacheSize/K, "NmethodSweepFraction");
 status &= verify_interval(NmethodSweepActivity, 0, 2000, "NmethodSweepActivity");
+if (!FLAG_IS_DEFAULT(CICompilerCount) && !FLAG_IS_DEFAULT(CICompilerCountPerCPU) && CICompilerCountPerCPU) {
+warning("The VM option CICompilerCountPerCPU overrides CICompilerCount.");
+}
 #ifdef COMPILER1
 status &= verify_interval(SafepointPollOffset, 0, os::vm_page_size() - BytesPerWord, "SafepointPollOffset");
 #endif
 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
 "; ignoring UseBiasedLocking flag." );
 }
 UseBiasedLocking = false;
 }
-#ifdef CC_INTERP
+#ifdef ZERO
-// Clear flags not supported by the C++ interpreter
+// Clear flags not supported on zero.
 FLAG_SET_DEFAULT(ProfileInterpreter, false);
 FLAG_SET_DEFAULT(UseBiasedLocking, false);
 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedOops, false));
 LP64_ONLY(FLAG_SET_DEFAULT(UseCompressedClassPointers, false));
 #endif // CC_INTERP
 #ifdef COMPILER2
-if (!UseBiasedLocking || EmitSync != 0) {
-UseOptoBiasInlining = false;
-}
 if (!EliminateLocks) {
 EliminateNestedLocks = false;
 }
 if (!Inline) {
 IncrementalInline = false;
 }
 if (UseTypeSpeculation && FLAG_IS_DEFAULT(ReplaceInParentMaps)) {
 // Doing the replace in parent maps helps speculation
 FLAG_SET_DEFAULT(ReplaceInParentMaps, true);
 }
-#ifndef X86
-// Only on x86 for now
-FLAG_SET_DEFAULT(TypeProfileLevel, 0);
-#endif
 #endif
 if (PrintAssembly && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
 warning("PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output");
 DebugNonSafepoints = true;
 if (!VM_Version::use_biased_locking() &&
 !(FLAG_IS_CMDLINE(UseBiasedLocking))) {
 UseBiasedLocking = false;
 }
 }
+#ifdef COMPILER2
+if (!UseBiasedLocking || EmitSync != 0) {
+UseOptoBiasInlining = false;
+}
+#endif
 // set PauseAtExit if the gamma launcher was used and a debugger is attached
 // but only if not already set on the commandline
 if (Arguments::created_by_gamma_launcher() && os::is_debugger_attached()) {
 bool set = false;

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/arguments.cpp @ 18058:54bc75c144b0