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

comparison src/share/vm/runtime/arguments.cpp @ 8883:b9a918201d47

Merge with hsx25

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Sat, 06 Apr 2013 20:04:06 +0200
parents	c92949b1ec8a 0c039865ef2b
children	89e4d67fdd2a

comparison

equal deleted inserted replaced

-:d47b52b0ff68
+:b9a918201d47
 { "MinPermHeapExpansion", JDK_Version::jdk(8),  JDK_Version::jdk(9) },
 { "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) },
 #ifdef PRODUCT
 { "DesiredMethodLimit",
 JDK_Version::jdk_update(7, 2), JDK_Version::jdk(8) },
 #endif // PRODUCT
 { NULL, JDK_Version(0), JDK_Version(0) }
 // as needed.
 if (UseParNewGC) {
 set_parnew_gc_flags();
 }
-// MaxHeapSize is aligned down in collectorPolicy
 size_t max_heap = align_size_down(MaxHeapSize,
 CardTableRS::ct_max_alignment_constraint());
 // Now make adjustments for CMS
 intx   tenuring_default = (intx)6;
 // Too early to use gclog_or_tty
 tty->print_cr("CMS ergo set MaxNewSize: " SIZE_FORMAT, MaxNewSize);
 }
 // Code along this path potentially sets NewSize and OldSize
-assert(max_heap >= InitialHeapSize, "Error");
-assert(max_heap >= NewSize, "Error");
 if (PrintGCDetails && Verbose) {
 // Too early to use gclog_or_tty
 tty->print_cr("CMS set min_heap_size: " SIZE_FORMAT
 " initial_heap_size:  " SIZE_FORMAT
 " max_heap: " SIZE_FORMAT,
 return true;
 }
 return false;
 }
+void Arguments::set_use_compressed_oops() {
+#ifndef ZERO
+#ifdef _LP64
+// MaxHeapSize is not set up properly at this point, but
+// the only value that can override MaxHeapSize if we are
+// to use UseCompressedOops is InitialHeapSize.
+size_t max_heap_size = MAX2(MaxHeapSize, InitialHeapSize);
+if (max_heap_size <= max_heap_for_compressed_oops()) {
+#if !defined(COMPILER1) || defined(TIERED)
+if (FLAG_IS_DEFAULT(UseCompressedOops)) {
+FLAG_SET_ERGO(bool, UseCompressedOops, true);
+}
+#endif
+#ifdef _WIN64
+if (UseLargePages && UseCompressedOops) {
+// Cannot allocate guard pages for implicit checks in indexed addressing
+// mode, when large pages are specified on windows.
+// This flag could be switched ON if narrow oop base address is set to 0,
+// see code in Universe::initialize_heap().
+Universe::set_narrow_oop_use_implicit_null_checks(false);
+}
+#endif //  _WIN64
+} else {
+if (UseCompressedOops && !FLAG_IS_DEFAULT(UseCompressedOops)) {
+warning("Max heap size too large for Compressed Oops");
+FLAG_SET_DEFAULT(UseCompressedOops, false);
+FLAG_SET_DEFAULT(UseCompressedKlassPointers, false);
+}
+}
+#endif // _LP64
+#endif // ZERO
+}
 void Arguments::set_ergonomics_flags() {
 if (os::is_server_class_machine()) {
 // If no other collector is requested explicitly,
 // let the VM select the collector based on
 }
 }
 #ifndef ZERO
 #ifdef _LP64
-// Check that UseCompressedOops can be set with the max heap size allocated
+set_use_compressed_oops();
-// by ergonomics.
-if (MaxHeapSize <= max_heap_for_compressed_oops()) {
-#if !defined(COMPILER1) || defined(TIERED)
-if (FLAG_IS_DEFAULT(UseCompressedOops)) {
-FLAG_SET_ERGO(bool, UseCompressedOops, true);
-}
-#endif
-#ifdef _WIN64
-if (UseLargePages && UseCompressedOops) {
-// Cannot allocate guard pages for implicit checks in indexed addressing
-// mode, when large pages are specified on windows.
-// This flag could be switched ON if narrow oop base address is set to 0,
-// see code in Universe::initialize_heap().
-Universe::set_narrow_oop_use_implicit_null_checks(false);
-}
-#endif //  _WIN64
-} else {
-if (UseCompressedOops && !FLAG_IS_DEFAULT(UseCompressedOops)) {
-warning("Max heap size too large for Compressed Oops");
-FLAG_SET_DEFAULT(UseCompressedOops, false);
-FLAG_SET_DEFAULT(UseCompressedKlassPointers, false);
-}
-}
 // UseCompressedOops must be on for UseCompressedKlassPointers to be on.
 if (!UseCompressedOops) {
 if (UseCompressedKlassPointers) {
 warning("UseCompressedKlassPointers requires UseCompressedOops");
 }
 MarkStackSize / K, MarkStackSizeMax / K);
 tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
 }
 }
+julong Arguments::limit_by_allocatable_memory(julong limit) {
+julong max_allocatable;
+julong result = limit;
+if (os::has_allocatable_memory_limit(&max_allocatable)) {
+result = MIN2(result, max_allocatable / MaxVirtMemFraction);
+}
+return result;
+}
 void Arguments::set_heap_size() {
 if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) {
 // Deprecated flag
 FLAG_SET_CMDLINE(uintx, MaxRAMFraction, DefaultMaxRAMFraction);
 }
 // but it should be not less than default MaxHeapSize.
 max_coop_heap -= HeapBaseMinAddress;
 }
 reasonable_max = MIN2(reasonable_max, max_coop_heap);
 }
-reasonable_max = os::allocatable_physical_memory(reasonable_max);
+reasonable_max = limit_by_allocatable_memory(reasonable_max);
 if (!FLAG_IS_DEFAULT(InitialHeapSize)) {
 // An initial heap size was specified on the command line,
 // so be sure that the maximum size is consistent.  Done
-// after call to allocatable_physical_memory because that
+// after call to limit_by_allocatable_memory because that
 // method might reduce the allocation size.
 reasonable_max = MAX2(reasonable_max, (julong)InitialHeapSize);
 }
 if (PrintGCDetails && Verbose) {
 if (FLAG_IS_DEFAULT(InitialHeapSize)) {
 julong reasonable_minimum = (julong)(OldSize + NewSize);
 reasonable_minimum = MIN2(reasonable_minimum, (julong)MaxHeapSize);
-reasonable_minimum = os::allocatable_physical_memory(reasonable_minimum);
+reasonable_minimum = limit_by_allocatable_memory(reasonable_minimum);
 julong reasonable_initial = phys_mem / InitialRAMFraction;
 reasonable_initial = MAX2(reasonable_initial, reasonable_minimum);
 reasonable_initial = MIN2(reasonable_initial, (julong)MaxHeapSize);
-reasonable_initial = os::allocatable_physical_memory(reasonable_initial);
+reasonable_initial = limit_by_allocatable_memory(reasonable_initial);
 if (PrintGCDetails && Verbose) {
 // Cannot use gclog_or_tty yet.
 tty->print_cr("  Initial heap size " SIZE_FORMAT, (uintx)reasonable_initial);
 tty->print_cr("  Minimum heap size " SIZE_FORMAT, (uintx)reasonable_minimum);
 "and will likely be removed in a future release");
 }
 if (CMSIncrementalMode) {
 warning("Using incremental CMS is deprecated and will likely be removed in a future release");
+}
+}
+void Arguments::check_deprecated_gc_flags() {
+if (FLAG_IS_CMDLINE(MaxGCMinorPauseMillis)) {
+warning("Using MaxGCMinorPauseMillis as minor pause goal is deprecated"
+"and will likely be removed in future release");
 }
 }
 // Check stack pages settings
 bool Arguments::check_stack_pages()
 size_t len2 = strlen(pos+1) + 1; // options start after ':'.  Final zero must be copied.
 options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2, mtInternal), pos+1, len2);
 }
 #if !INCLUDE_JVMTI
 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) {
-warning("profiling and debugging agents are not supported in this VM");
+jio_fprintf(defaultStream::error_stream(),
-} else
+"Profiling and debugging agents are not supported in this VM\n");
+return JNI_ERR;
+}
 #endif // !INCLUDE_JVMTI
 add_init_library(name, options);
 }
 // -agentlib and -agentpath
 } else if (match_option(option, "-agentlib:", &tail) ||
 (is_absolute_path = match_option(option, "-agentpath:", &tail))) {
 if(tail != NULL) {
 if(pos != NULL) {
 options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1, mtInternal), pos + 1);
 }
 #if !INCLUDE_JVMTI
 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) {
-warning("profiling and debugging agents are not supported in this VM");
+jio_fprintf(defaultStream::error_stream(),
-} else
+"Profiling and debugging agents are not supported in this VM\n");
+return JNI_ERR;
+}
 #endif // !INCLUDE_JVMTI
 add_init_agent(name, options, is_absolute_path);
 }
 // -javaagent
 } else if (match_option(option, "-javaagent:", &tail)) {
 #if !INCLUDE_JVMTI
-warning("Instrumentation agents are not supported in this VM");
+jio_fprintf(defaultStream::error_stream(),
+"Instrumentation agents are not supported in this VM\n");
+return JNI_ERR;
 #else
 if(tail != NULL) {
 char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1, mtInternal), tail);
 add_init_agent("instrument", options, false);
 }
 // -Xprof
 } else if (match_option(option, "-Xprof", &tail)) {
 #if INCLUDE_FPROF
 _has_profile = true;
 #else // INCLUDE_FPROF
-// do we have to exit?
+jio_fprintf(defaultStream::error_stream(),
-warning("Flat profiling is not supported in this VM.");
+"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
 // Out of the box management support
 if (match_option(option, "-Dcom.sun.management", &tail)) {
 #if INCLUDE_MANAGEMENT
 FLAG_SET_CMDLINE(bool, ManagementServer, true);
 #else
-vm_exit_during_initialization(
+jio_fprintf(defaultStream::output_stream(),
-"-Dcom.sun.management is not supported in this VM.", NULL);
+"-Dcom.sun.management is not supported in this VM.\n");
+return JNI_ERR;
 #endif
 }
 // -Xint
 } else if (match_option(option, "-Xint", &tail)) {
 set_mode_flags(_int);
 set_mode_flags(_mixed);
 // -Xcomp
 } else if (match_option(option, "-Xcomp", &tail)) {
 // for testing the compiler; turn off all flags that inhibit compilation
 set_mode_flags(_comp);
 // -Xshare:dump
 } else if (match_option(option, "-Xshare:dump", &tail)) {
-#if !INCLUDE_CDS
-vm_exit_during_initialization(
-"Dumping a shared archive is not supported in this VM.", NULL);
-#else
 FLAG_SET_CMDLINE(bool, DumpSharedSpaces, true);
 set_mode_flags(_int);     // Prevent compilation, which creates objects
-#endif
 // -Xshare:on
 } else if (match_option(option, "-Xshare:on", &tail)) {
 FLAG_SET_CMDLINE(bool, UseSharedSpaces, true);
 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, true);
 // -Xshare:auto
 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, false);
 // -Xshare:off
 } else if (match_option(option, "-Xshare:off", &tail)) {
 FLAG_SET_CMDLINE(bool, UseSharedSpaces, false);
 FLAG_SET_CMDLINE(bool, RequireSharedSpaces, false);
 // -Xverify
 } else if (match_option(option, "-Xverify", &tail)) {
 if (strcmp(tail, ":all") == 0 || strcmp(tail, "") == 0) {
 FLAG_SET_CMDLINE(bool, BytecodeVerificationLocal, true);
 FLAG_SET_CMDLINE(bool, BytecodeVerificationRemote, true);
 // is turned on below, the actual space used may be smaller.
 initHeapSize = MIN2(total_memory / (julong)2,
 total_memory - (julong)160*M);
-// Make sure that if we have a lot of memory we cap the 32 bit
+initHeapSize = limit_by_allocatable_memory(initHeapSize);
-// process space.  The 64bit VM version of this function is a nop.
-initHeapSize = os::allocatable_physical_memory(initHeapSize);
 if (FLAG_IS_DEFAULT(MaxHeapSize)) {
 FLAG_SET_CMDLINE(uintx, MaxHeapSize, initHeapSize);
 FLAG_SET_CMDLINE(uintx, InitialHeapSize, initHeapSize);
 // Currently the minimum size and the initial heap sizes are the same.
 //       away and will cause VM initialization failures!
 warning("-XX:+UseVMInterruptibleIO is obsolete and will be removed in a future release.");
 FLAG_SET_CMDLINE(bool, UseVMInterruptibleIO, true);
 #if !INCLUDE_MANAGEMENT
 } else if (match_option(option, "-XX:+ManagementServer", &tail)) {
-vm_exit_during_initialization(
+jio_fprintf(defaultStream::error_stream(),
-"ManagementServer is not supported in this VM.", NULL);
+"ManagementServer is not supported in this VM.\n");
+return JNI_ERR;
 #endif // INCLUDE_MANAGEMENT
 } else if (match_option(option, "-XX:", &tail)) { // -XX:xxxx
 // Skip -XX:Flags= since that case has already been handled
 if (strncmp(tail, "Flags=", strlen("Flags=")) != 0) {
 if (!process_argument(tail, args->ignoreUnrecognized, origin)) {
 }
 if (match_option(option, "-XX:NativeMemoryTracking", &tail)) {
 #if INCLUDE_NMT
 MemTracker::init_tracking_options(tail);
 #else
-warning("Native Memory Tracking is not supported in this VM");
+jio_fprintf(defaultStream::error_stream(),
+"Native Memory Tracking is not supported in this VM\n");
+return JNI_ERR;
 #endif
 }
 #ifndef PRODUCT
 #if !INCLUDE_ALL_GCS
 force_serial_gc();
 #endif // INCLUDE_ALL_GCS
 #if !INCLUDE_CDS
+if (DumpSharedSpaces || RequireSharedSpaces) {
+jio_fprintf(defaultStream::error_stream(),
+"Shared spaces are not supported in this VM\n");
+return JNI_ERR;
+}
+if ((UseSharedSpaces && FLAG_IS_CMDLINE(UseSharedSpaces)) || PrintSharedSpaces) {
+warning("Shared spaces are not supported in this VM");
+FLAG_SET_DEFAULT(UseSharedSpaces, false);
+FLAG_SET_DEFAULT(PrintSharedSpaces, false);
+}
 no_shared_spaces();
 #endif // INCLUDE_CDS
 // Set flags based on ergonomics.
 set_ergonomics_flags();
 set_parnew_gc_flags();
 } else if (UseG1GC) {
 set_g1_gc_flags();
 }
 check_deprecated_gcs();
+check_deprecated_gc_flags();
+if (AssumeMP && !UseSerialGC) {
+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");
+}
+}
 #else // INCLUDE_ALL_GCS
 assert(verify_serial_gc_flags(), "SerialGC unset");
 #endif // INCLUDE_ALL_GCS
 // Set bytecode rewriting flags

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/arguments.cpp @ 8883:b9a918201d47