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

comparison src/share/vm/runtime/arguments.cpp @ 11198:1e6d5dec4a4e

Merge.

author	Christian Humer <christian.humer@gmail.com>
date	Mon, 05 Aug 2013 13:20:06 +0200
parents	0630959b64e8
children	e28663a9f5ef

comparison

equal deleted inserted replaced

-:3479ab380552
+:1e6d5dec4a4e
 #endif
 char*  Arguments::_java_command                 = NULL;
 SystemProperty* Arguments::_system_properties   = NULL;
 const char*  Arguments::_gc_log_filename        = NULL;
 bool   Arguments::_has_profile                  = false;
-bool   Arguments::_has_alloc_profile            = false;
 uintx  Arguments::_min_heap_size                = 0;
 Arguments::Mode Arguments::_mode                = _mixed;
 bool   Arguments::_java_compiler                = false;
 bool   Arguments::_xdebug_mode                  = false;
 const char*  Arguments::_java_vendor_url_bug    = DEFAULT_VENDOR_URL_BUG;
 { "MaxPermHeapExpansion", JDK_Version::jdk(8),  JDK_Version::jdk(9) },
 { "CMSRevisitStackSize",           JDK_Version::jdk(8), JDK_Version::jdk(9) },
 { "PrintRevisitStats",             JDK_Version::jdk(8), JDK_Version::jdk(9) },
 { "UseVectoredExceptions",         JDK_Version::jdk(8), JDK_Version::jdk(9) },
 { "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) },
 #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((char*)argname, arg_len, true);
+Flag* found_flag = Flag::find_flag((const char*)argname, arg_len, 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) {
 jio_fprintf(defaultStream::error_stream(), "%s", locked_message_buf);
 }
 } else {
 jio_fprintf(defaultStream::error_stream(),
 "Unrecognized VM option '%s'\n", argname);
+Flag* fuzzy_matched = Flag::fuzzy_match((const char*)argname, arg_len, true);
+if (fuzzy_matched != NULL) {
+jio_fprintf(defaultStream::error_stream(),
+"Did you mean '%s%s%s'?\n",
+(fuzzy_matched->is_bool()) ? "(+/-)" : "",
+fuzzy_matched->name,
+(fuzzy_matched->is_bool()) ? "" : "=<value>");
+}
 }
 // allow for commandline "commenting out" options like -XX:#+Verbose
 return arg[0] == '#';
 }
 result = MIN2(result, max_allocatable / MaxVirtMemFraction);
 }
 return result;
 }
+void Arguments::set_heap_base_min_address() {
+if (FLAG_IS_DEFAULT(HeapBaseMinAddress) && UseG1GC && HeapBaseMinAddress < 1*G) {
+// By default HeapBaseMinAddress is 2G on all platforms except Solaris x86.
+// G1 currently needs a lot of C-heap, so on Solaris we have to give G1
+// some extra space for the C-heap compared to other collectors.
+// Use FLAG_SET_DEFAULT here rather than FLAG_SET_ERGO to make sure that
+// code that checks for default values work correctly.
+FLAG_SET_DEFAULT(HeapBaseMinAddress, 1*G);
+}
+}
 void Arguments::set_heap_size() {
 if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) {
 // Deprecated flag
 FLAG_SET_CMDLINE(uintx, MaxRAMFraction, DefaultMaxRAMFraction);
 }
 jio_fprintf(defaultStream::error_stream(),
 "Conflicting collector combinations in option list; "
 "please refer to the release notes for the combinations "
 "allowed\n");
 status = false;
-}
+} else if (ReservedCodeCacheSize > 2*G) {
+// Code cache size larger than MAXINT is not supported.
+jio_fprintf(defaultStream::error_stream(),
+"Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M,
+(2*G)/M);
+status = false;
+}
 return status;
 }
 void Arguments::check_deprecated_gcs() {
 if (UseConcMarkSweepGC && !UseParNewGC) {
 // The intent is to warn the user of all possible conflicts,
 // before returning an error.
 // Note: Needs platform-dependent factoring.
 bool status = true;
-#if ( (defined(COMPILER2) && defined(SPARC)))
-// NOTE: The call to VM_Version_init depends on the fact that VM_Version_init
-// on sparc doesn't require generation of a stub as is the case on, e.g.,
-// x86.  Normally, VM_Version_init must be called from init_globals in
-// init.cpp, which is called by the initial java thread *after* arguments
-// have been parsed.  VM_Version_init gets called twice on sparc.
-extern void VM_Version_init();
-VM_Version_init();
-if (!VM_Version::has_v9()) {
-jio_fprintf(defaultStream::error_stream(),
-"V8 Machine detected, Server requires V9\n");
-status = false;
-}
-#endif /* COMPILER2 && SPARC */
 // Allow both -XX:-UseStackBanging and -XX:-UseBoundThreads in non-product
 // builds so the cost of stack banging can be measured.
 #if (defined(PRODUCT) && defined(SOLARIS))
 if (!UseBoundThreads && !UseStackBanging) {
 jio_fprintf(defaultStream::error_stream(),
 FLAG_SET_DEFAULT(UseGCOverheadLimit, false);
 }
 status = status && check_gc_consistency();
 status = status && check_stack_pages();
-if (_has_alloc_profile) {
-if (UseParallelGC || UseParallelOldGC) {
-jio_fprintf(defaultStream::error_stream(),
-"error:  invalid argument combination.\n"
-"Allocation profiling (-Xaprof) cannot be used together with "
-"Parallel GC (-XX:+UseParallelGC or -XX:+UseParallelOldGC).\n");
-status = false;
-}
-if (UseConcMarkSweepGC) {
-jio_fprintf(defaultStream::error_stream(),
-"error:  invalid argument combination.\n"
-"Allocation profiling (-Xaprof) cannot be used together with "
-"the CMS collector (-XX:+UseConcMarkSweepGC).\n");
-status = false;
-}
-}
 if (CMSIncrementalMode) {
 if (!UseConcMarkSweepGC) {
 jio_fprintf(defaultStream::error_stream(),
 "error:  invalid argument combination.\n"
 if (!ScavengeRootsInCode) {
 warning("forcing ScavengeRootsInCode non-zero because Graal is enabled");
 ScavengeRootsInCode = 1;
 }
+if (UseCRC32Intrinsics) {
+// For some yet to be determined reason, enabling CRC32 intrinsics causes
+// a Graal compiled call to 'static java.util.zip.CRC32.update(int crc, int b)'
+// to crash the VM
+warning("disabling CRC32 intrinsics because Graal is enabled");
+}
+// This prevents the flag being set to true by VM_Version::get_processor_features()
+FLAG_SET_CMDLINE(bool, UseCRC32Intrinsics, false);
 #endif
+// Need to limit the extent of the padding to reasonable size.
+// 8K is well beyond the reasonable HW cache line size, even with the
+// aggressive prefetching, while still leaving the room for segregating
+// among the distinct pages.
+if (ContendedPaddingWidth < 0 || ContendedPaddingWidth > 8192) {
+jio_fprintf(defaultStream::error_stream(),
+"ContendedPaddingWidth=" INTX_FORMAT " must be the between %d and %d\n",
+ContendedPaddingWidth, 0, 8192);
+status = false;
+}
+// Need to enforce the padding not to break the existing field alignments.
+// It is sufficient to check against the largest type size.
+if ((ContendedPaddingWidth % BytesPerLong) != 0) {
+jio_fprintf(defaultStream::error_stream(),
+"ContendedPaddingWidth=" INTX_FORMAT " must be the multiple of %d\n",
+ContendedPaddingWidth, BytesPerLong);
+status = false;
+}
+// Check lower bounds of the code cache
+// Template Interpreter code is approximately 3X larger in debug builds.
+uint min_code_cache_size = (CodeCacheMinimumUseSpace DEBUG_ONLY(* 3)) + CodeCacheMinimumFreeSpace;
+if (InitialCodeCacheSize < (uintx)os::vm_page_size()) {
+jio_fprintf(defaultStream::error_stream(),
+"Invalid InitialCodeCacheSize=%dK. Must be at least %dK.\n", InitialCodeCacheSize/K,
+os::vm_page_size()/K);
+status = false;
+} else if (ReservedCodeCacheSize < InitialCodeCacheSize) {
+jio_fprintf(defaultStream::error_stream(),
+"Invalid ReservedCodeCacheSize: %dK. Must be at least InitialCodeCacheSize=%dK.\n",
+ReservedCodeCacheSize/K, InitialCodeCacheSize/K);
+status = false;
+} else if (ReservedCodeCacheSize < min_code_cache_size) {
+jio_fprintf(defaultStream::error_stream(),
+"Invalid ReservedCodeCacheSize=%dK. Must be at least %uK.\n", ReservedCodeCacheSize/K,
+min_code_cache_size/K);
+status = false;
+} else if (ReservedCodeCacheSize > 2*G) {
+// Code cache size larger than MAXINT is not supported.
+jio_fprintf(defaultStream::error_stream(),
+"Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M,
+(2*G)/M);
+status = false;
+}
 return status;
 }
 bool Arguments::is_bad_option(const JavaVMOption* option, jboolean ignore,
 const char* option_type) {
 FLAG_SET_CMDLINE(intx, ThreadStackSize,
 round_to((int)long_ThreadStackSize, K) / K);
 // -Xoss
 } else if (match_option(option, "-Xoss", &tail)) {
 // HotSpot does not have separate native and Java stacks, ignore silently for compatibility
-// -Xmaxjitcodesize
+} else if (match_option(option, "-XX:CodeCacheExpansionSize=", &tail)) {
+julong long_CodeCacheExpansionSize = 0;
+ArgsRange errcode = parse_memory_size(tail, &long_CodeCacheExpansionSize, os::vm_page_size());
+if (errcode != arg_in_range) {
+jio_fprintf(defaultStream::error_stream(),
+"Invalid argument: %s. Must be at least %luK.\n", option->optionString,
+os::vm_page_size()/K);
+return JNI_EINVAL;
+}
+FLAG_SET_CMDLINE(uintx, CodeCacheExpansionSize, (uintx)long_CodeCacheExpansionSize);
 } else if (match_option(option, "-Xmaxjitcodesize", &tail) ||
 match_option(option, "-XX:ReservedCodeCacheSize=", &tail)) {
 julong long_ReservedCodeCacheSize = 0;
 ArgsRange errcode = parse_memory_size(tail, &long_ReservedCodeCacheSize, 1);
 if (errcode != arg_in_range) {
 jio_fprintf(defaultStream::error_stream(),
 "Invalid maximum code cache size: %s.\n", option->optionString);
 return JNI_EINVAL;
 #else // INCLUDE_FPROF
 jio_fprintf(defaultStream::error_stream(),
 "Flat profiling is not supported in this VM.\n");
 return JNI_ERR;
 #endif // INCLUDE_FPROF
-// -Xaprof
-} else if (match_option(option, "-Xaprof", &tail)) {
-_has_alloc_profile = true;
 // -Xconcurrentio
 } else if (match_option(option, "-Xconcurrentio", &tail)) {
 FLAG_SET_CMDLINE(bool, UseLWPSynchronization, true);
 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false);
 FLAG_SET_CMDLINE(intx, DeferThrSuspendLoopCount, 1);
 // No longer used.
 } else if (match_option(option, "-XX:+UseTLE", &tail)) {
 FLAG_SET_CMDLINE(bool, UseTLAB, true);
 } else if (match_option(option, "-XX:-UseTLE", &tail)) {
 FLAG_SET_CMDLINE(bool, UseTLAB, false);
-SOLARIS_ONLY(
-} else if (match_option(option, "-XX:+UsePermISM", &tail)) {
-warning("-XX:+UsePermISM is obsolete.");
-FLAG_SET_CMDLINE(bool, UseISM, true);
-} else if (match_option(option, "-XX:-UsePermISM", &tail)) {
-FLAG_SET_CMDLINE(bool, UseISM, false);
-)
 } else if (match_option(option, "-XX:+DisplayVMOutputToStderr", &tail)) {
 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStdout, false);
 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, true);
 } else if (match_option(option, "-XX:+DisplayVMOutputToStdout", &tail)) {
 FLAG_SET_CMDLINE(bool, DisplayVMOutputToStderr, false);
 MaxHeapSize < LargePageHeapSizeThreshold) {
 // No need for large granularity pages w/small heaps.
 // Note that large pages are enabled/disabled for both the
 // Java heap and the code cache.
 FLAG_SET_DEFAULT(UseLargePages, false);
-SOLARIS_ONLY(FLAG_SET_DEFAULT(UseMPSS, false));
-SOLARIS_ONLY(FLAG_SET_DEFAULT(UseISM, false));
 }
 // Tiered compilation is undefined with C1.
 TieredCompilation = false;
 #else
 vm_exit_during_initialization(
 "Incompatible compilation policy selected", NULL);
 }
 }
+set_heap_base_min_address();
 // Set heap size based on available physical memory
 set_heap_size();
 #if INCLUDE_ALL_GCS
 // Set per-collector flags

Mercurial > hg > truffle

comparison src/share/vm/runtime/arguments.cpp @ 11198:1e6d5dec4a4e