truffle: src/share/vm/runtime/arguments.cpp comparison

comparison src/share/vm/runtime/arguments.cpp @ 14518:d8041d695d19

Merged with jdk9/dev/hotspot changeset 3812c088b945

author	twisti
date	Tue, 11 Mar 2014 18:45:59 -0700
parents	49db2c1e3bee 16c705d792be
children	b51e29501f30 4ca6dc0799b6

comparison

equal deleted inserted replaced

-:f97c5ec83832
+:d8041d695d19
 /*
-* 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.
 # 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
 #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
 bool   Arguments::_java_compiler                = false;
 bool   Arguments::_xdebug_mode                  = false;
 const char*  Arguments::_java_vendor_url_bug    = DEFAULT_VENDOR_URL_BUG;
 const char*  Arguments::_sun_java_launcher      = DEFAULT_JAVA_LAUNCHER;
 int    Arguments::_sun_java_launcher_pid        = -1;
-bool   Arguments::_created_by_gamma_launcher    = false;
+bool   Arguments::_sun_java_launcher_is_altjvm  = false;
 // These parameters are reset in method parse_vm_init_args(JavaVMInitArgs*)
 bool   Arguments::_AlwaysCompileLoopMethods     = AlwaysCompileLoopMethods;
 bool   Arguments::_UseOnStackReplacement        = UseOnStackReplacement;
 bool   Arguments::_BackgroundCompilation        = BackgroundCompilation;
 }
 }
 // Process java launcher properties.
 void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) {
-// See if sun.java.launcher or sun.java.launcher.pid is defined.
+// See if sun.java.launcher, sun.java.launcher.is_altjvm or
+// sun.java.launcher.pid is defined.
 // Must do this before setting up other system properties,
 // as some of them may depend on launcher type.
 for (int index = 0; index < args->nOptions; index++) {
 const JavaVMOption* option = args->options + index;
 const char* tail;
 if (match_option(option, "-Dsun.java.launcher=", &tail)) {
 process_java_launcher_argument(tail, option->extraInfo);
 continue;
 }
+if (match_option(option, "-Dsun.java.launcher.is_altjvm=", &tail)) {
+if (strcmp(tail, "true") == 0) {
+_sun_java_launcher_is_altjvm = true;
+}
+continue;
+}
 if (match_option(option, "-Dsun.java.launcher.pid=", &tail)) {
 _sun_java_launcher_pid = atoi(tail);
 continue;
 }
 }
 "Java Virtual Machine Specification",  false));
 PropertyList_add(&_system_properties, new SystemProperty("java.vm.version", VM_Version::vm_release(),  false));
 PropertyList_add(&_system_properties, new SystemProperty("java.vm.name", VM_Version::vm_name(),  false));
 PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(),  true));
-// following are JVMTI agent writeable properties.
+// Following are JVMTI agent writable properties.
 // Properties values are set to NULL and they are
 // os specific they are initialized in os::init_system_properties_values().
 _java_ext_dirs = new SystemProperty("java.ext.dirs", NULL,  true);
 _java_endorsed_dirs = new SystemProperty("java.endorsed.dirs", NULL,  true);
 _sun_boot_library_path = new SystemProperty("sun.boot.library.path", NULL,  true);
 { "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) }
 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) {
 return true;
 } else if (strcmp(key, "sun.java.command") == 0) {
 _java_command = value;
 // Record value in Arguments, but let it get passed to Java.
-} else if (strcmp(key, "sun.java.launcher.pid") == 0) {
+} else if (strcmp(key, "sun.java.launcher.is_altjvm") == 0 ||
-// launcher.pid property is private and is processed
+strcmp(key, "sun.java.launcher.pid") == 0) {
-// in process_sun_java_launcher_properties();
+// sun.java.launcher.is_altjvm and sun.java.launcher.pid property are
+// private and are processed in process_sun_java_launcher_properties();
 // the sun.java.launcher property is passed on to the java application
 FreeHeap(key);
 if (eq != NULL) {
 FreeHeap(value);
 }
 // with YoungPLABSize and OldPLABSize options.
 // See CR 6362902.
 if (!FLAG_IS_DEFAULT(OldPLABSize)) {
 if (FLAG_IS_DEFAULT(CMSParPromoteBlocksToClaim)) {
 // OldPLABSize is not the default value but CMSParPromoteBlocksToClaim
-// is.  In this situtation let CMSParPromoteBlocksToClaim follow
+// is.  In this situation let CMSParPromoteBlocksToClaim follow
 // the value (either from the command line or ergonomics) of
 // OldPLABSize.  Following OldPLABSize is an ergonomics decision.
 FLAG_SET_ERGO(uintx, CMSParPromoteBlocksToClaim, OldPLABSize);
 } else {
 // OldPLABSize and CMSParPromoteBlocksToClaim are both set.
 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.
 result = MIN2(result, max_allocatable / MaxVirtMemFraction);
 }
 return result;
 }
+// Use static initialization to get the default before parsing
+static const uintx DefaultHeapBaseMinAddress = HeapBaseMinAddress;
 void Arguments::set_heap_size() {
 if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) {
 // Deprecated flag
 FLAG_SET_CMDLINE(uintx, MaxRAMFraction, DefaultMaxRAMFraction);
 }
 reasonable_max = MIN2(reasonable_max, (julong)ErgoHeapSizeLimit);
 }
 if (UseCompressedOops) {
 // Limit the heap size to the maximum possible when using compressed oops
 julong max_coop_heap = (julong)max_heap_for_compressed_oops();
+// HeapBaseMinAddress can be greater than default but not less than.
+if (!FLAG_IS_DEFAULT(HeapBaseMinAddress)) {
+if (HeapBaseMinAddress < DefaultHeapBaseMinAddress) {
+if (PrintMiscellaneous && Verbose) {  // matches compressed oops printing flags
+jio_fprintf(defaultStream::error_stream(),
+"HeapBaseMinAddress must be at least " UINTX_FORMAT
+" (" UINTX_FORMAT "G) which is greater than value given "
+UINTX_FORMAT "\n",
+DefaultHeapBaseMinAddress,
+DefaultHeapBaseMinAddress/G,
+HeapBaseMinAddress);
+}
+FLAG_SET_ERGO(uintx, HeapBaseMinAddress, DefaultHeapBaseMinAddress);
+}
+}
 if (HeapBaseMinAddress + MaxHeapSize < max_coop_heap) {
 // Heap should be above HeapBaseMinAddress to get zero based compressed oops
 // but it should be not less than default MaxHeapSize.
 max_coop_heap -= HeapBaseMinAddress;
 }
 }
 }
 void Arguments::process_java_launcher_argument(const char* launcher, void* extra_info) {
 _sun_java_launcher = strdup(launcher);
-if (strcmp("gamma", _sun_java_launcher) == 0) {
-_created_by_gamma_launcher = true;
-}
 }
 bool Arguments::created_by_java_launcher() {
 assert(_sun_java_launcher != NULL, "property must have value");
 return strcmp(DEFAULT_JAVA_LAUNCHER, _sun_java_launcher) != 0;
 }
-bool Arguments::created_by_gamma_launcher() {
+bool Arguments::sun_java_launcher_is_altjvm() {
-return _created_by_gamma_launcher;
+return _sun_java_launcher_is_altjvm;
 }
 //===========================================================================================================
 // Parsing of main arguments
 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");
 status = false;
 }
 status &= verify_interval(NmethodSweepFraction, 1, ReservedCodeCacheSize/K, "NmethodSweepFraction");
 status &= verify_interval(NmethodSweepActivity, 0, 2000, "NmethodSweepActivity");
+// TieredCompilation needs at least 2 compiler threads.
+const int num_min_compiler_threads = (TieredCompilation) ? NOT_GRAAL(2) GRAAL_ONLY(1) : 1;
+status &=verify_min_value(CICompilerCount, num_min_compiler_threads, "CICompilerCount");
 return status;
 }
 bool Arguments::is_bad_option(const JavaVMOption* option, jboolean ignore,
 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();
 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
-// Initialize Metaspace flags and alignments.
+// Initialize Metaspace flags and alignments
 Metaspace::ergo_initialize();
 // Set bytecode rewriting flags
 set_bytecode_flags();
-// Set flags if Aggressive optimization flags (-XX:+AggressiveOpts) enabled.
+// Set flags if Aggressive optimization flags (-XX:+AggressiveOpts) enabled
 set_aggressive_opts_flags();
 // Turn off biased locking for locking debug mode flags,
-// which are subtlely different from each other but neither works with
+// which are subtly different from each other but neither works with
-// biased locking.
+// biased locking
 if (UseHeavyMonitors
 #ifdef COMPILER1
 || !UseFastLocking
 #endif // COMPILER1
 #ifdef GRAAL
 "; 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
 }
 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;
 !(FLAG_IS_CMDLINE(UseBiasedLocking))) {
 UseBiasedLocking = false;
 }
 }
-// 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;
-CommandLineFlags::wasSetOnCmdline("PauseAtExit", &set);
-if (!set) {
-FLAG_SET_DEFAULT(PauseAtExit, true);
-}
-}
 return JNI_OK;
 }
 jint Arguments::adjust_after_os() {
-#if INCLUDE_ALL_GCS
+if (UseNUMA) {
 if (UseParallelGC || UseParallelOldGC) {
-if (UseNUMA) {
 if (FLAG_IS_DEFAULT(MinHeapDeltaBytes)) {
 FLAG_SET_DEFAULT(MinHeapDeltaBytes, 64*M);
 }
-// For those collectors or operating systems (eg, Windows) that do
+}
-// not support full UseNUMA, we will map to UseNUMAInterleaving for now
+// UseNUMAInterleaving is set to ON for all collectors and
-UseNUMAInterleaving = true;
+// platforms when UseNUMA is set to ON. NUMA-aware collectors
-}
+// such as the parallel collector for Linux and Solaris will
-}
+// interleave old gen and survivor spaces on top of NUMA
-#endif // INCLUDE_ALL_GCS
+// allocation policy for the eden space.
+// Non NUMA-aware collectors such as CMS, G1 and Serial-GC on
+// all platforms and ParallelGC on Windows will interleave all
+// of the heap spaces across NUMA nodes.
+if (FLAG_IS_DEFAULT(UseNUMAInterleaving)) {
+FLAG_SET_ERGO(bool, UseNUMAInterleaving, true);
+}
+}
 return JNI_OK;
 }
 int Arguments::PropertyList_count(SystemProperty* pl) {
 int count = 0;

Mercurial > hg > truffle

comparison src/share/vm/runtime/arguments.cpp @ 14518:d8041d695d19