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

comparison src/share/vm/runtime/arguments.cpp @ 7482:989155e2d07a

Merge with hs25-b15.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Wed, 16 Jan 2013 01:34:24 +0100
parents	2912b72d840a f1c06dcee0b5
children	3ac7d10a6572

comparison

equal deleted inserted replaced

-:6761a8f854a4
+:989155e2d07a
 }
 FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false);
 }
 }
-// If the user has chosen ParallelGCThreads > 0, we set UseParNewGC
-// if it's not explictly set or unset. If the user has chosen
-// UseParNewGC and not explicitly set ParallelGCThreads we
-// set it, unless this is a single cpu machine.
 void Arguments::set_parnew_gc_flags() {
 assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC && !UseG1GC,
 "control point invariant");
 assert(UseParNewGC, "Error");
 // Turn off AdaptiveSizePolicy for parnew until it is complete.
 disable_adaptive_size_policy("UseParNewGC");
-if (ParallelGCThreads == 0) {
+if (FLAG_IS_DEFAULT(ParallelGCThreads)) {
-FLAG_SET_DEFAULT(ParallelGCThreads,
+FLAG_SET_DEFAULT(ParallelGCThreads, Abstract_VM_Version::parallel_worker_threads());
-Abstract_VM_Version::parallel_worker_threads());
+assert(ParallelGCThreads > 0, "We should always have at least one thread by default");
-if (ParallelGCThreads == 1) {
+} else if (ParallelGCThreads == 0) {
-FLAG_SET_DEFAULT(UseParNewGC, false);
+jio_fprintf(defaultStream::error_stream(),
-FLAG_SET_DEFAULT(ParallelGCThreads, 0);
+"The ParNew GC can not be combined with -XX:ParallelGCThreads=0\n");
-}
+vm_exit(1);
 }
-if (UseParNewGC) {
 // By default YoungPLABSize and OldPLABSize are set to 4096 and 1024 respectively,
 // these settings are default for Parallel Scavenger. For ParNew+Tenured configuration
 // we set them to 1024 and 1024.
 // See CR 6362902.
 if (FLAG_IS_DEFAULT(YoungPLABSize)) {
 FLAG_SET_DEFAULT(YoungPLABSize, (intx)1024);
 }
 if (FLAG_IS_DEFAULT(OldPLABSize)) {
 FLAG_SET_DEFAULT(OldPLABSize, (intx)1024);
 }
 // AlwaysTenure flag should make ParNew promote all at first collection.
 // See CR 6362902.
 if (AlwaysTenure) {
 FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, 0);
 }
 // When using compressed oops, we use local overflow stacks,
 // rather than using a global overflow list chained through
 // the klass word of the object's pre-image.
 if (UseCompressedOops && !ParGCUseLocalOverflow) {
 if (!FLAG_IS_DEFAULT(ParGCUseLocalOverflow)) {
 warning("Forcing +ParGCUseLocalOverflow: needed if using compressed references");
 }
 FLAG_SET_DEFAULT(ParGCUseLocalOverflow, true);
 }
 assert(ParGCUseLocalOverflow || !UseCompressedOops, "Error");
-}
 }
 // Adjust some sizes to suit CMS and/or ParNew needs; these work well on
 // sparc/solaris for certain applications, but would gain from
 // further optimization and tuning efforts, and would almost
 // It does not make sense to have big object alignment
 // since a space lost due to alignment will be greater
 // then a saved space from compressed oops.
 if ((int)ObjectAlignmentInBytes > 256) {
 jio_fprintf(defaultStream::error_stream(),
-"error: ObjectAlignmentInBytes=%d must not be greater then 256\n",
+"error: ObjectAlignmentInBytes=%d must not be greater than 256\n",
 (int)ObjectAlignmentInBytes);
 return false;
 }
 // In case page size is very small.
 if ((int)ObjectAlignmentInBytes >= os::vm_page_size()) {
 jio_fprintf(defaultStream::error_stream(),
-"error: ObjectAlignmentInBytes=%d must be less then page size %d\n",
+"error: ObjectAlignmentInBytes=%d must be less than page size %d\n",
 (int)ObjectAlignmentInBytes, os::vm_page_size());
 return false;
 }
 return true;
 }
 }
 FLAG_SET_DEFAULT(UseParallelGC, true);
 // If no heap maximum was requested explicitly, use some reasonable fraction
 // of the physical memory, up to a maximum of 1GB.
-if (UseParallelGC) {
+FLAG_SET_DEFAULT(ParallelGCThreads,
-FLAG_SET_DEFAULT(ParallelGCThreads,
+Abstract_VM_Version::parallel_worker_threads());
-Abstract_VM_Version::parallel_worker_threads());
+if (ParallelGCThreads == 0) {
+jio_fprintf(defaultStream::error_stream(),
-// If InitialSurvivorRatio or MinSurvivorRatio were not specified, but the
+"The Parallel GC can not be combined with -XX:ParallelGCThreads=0\n");
-// SurvivorRatio has been set, reset their default values to SurvivorRatio +
+vm_exit(1);
-// 2.  By doing this we make SurvivorRatio also work for Parallel Scavenger.
+}
-// See CR 6362902 for details.
-if (!FLAG_IS_DEFAULT(SurvivorRatio)) {
-if (FLAG_IS_DEFAULT(InitialSurvivorRatio)) {
+// If InitialSurvivorRatio or MinSurvivorRatio were not specified, but the
-FLAG_SET_DEFAULT(InitialSurvivorRatio, SurvivorRatio + 2);
+// SurvivorRatio has been set, reset their default values to SurvivorRatio +
-}
+// 2.  By doing this we make SurvivorRatio also work for Parallel Scavenger.
-if (FLAG_IS_DEFAULT(MinSurvivorRatio)) {
+// See CR 6362902 for details.
-FLAG_SET_DEFAULT(MinSurvivorRatio, SurvivorRatio + 2);
+if (!FLAG_IS_DEFAULT(SurvivorRatio)) {
-}
+if (FLAG_IS_DEFAULT(InitialSurvivorRatio)) {
-}
+FLAG_SET_DEFAULT(InitialSurvivorRatio, SurvivorRatio + 2);
+}
-if (UseParallelOldGC) {
+if (FLAG_IS_DEFAULT(MinSurvivorRatio)) {
-// Par compact uses lower default values since they are treated as
+FLAG_SET_DEFAULT(MinSurvivorRatio, SurvivorRatio + 2);
-// minimums.  These are different defaults because of the different
+}
-// interpretation and are not ergonomically set.
+}
-if (FLAG_IS_DEFAULT(MarkSweepDeadRatio)) {
-FLAG_SET_DEFAULT(MarkSweepDeadRatio, 1);
+if (UseParallelOldGC) {
-}
+// Par compact uses lower default values since they are treated as
+// minimums.  These are different defaults because of the different
+// interpretation and are not ergonomically set.
+if (FLAG_IS_DEFAULT(MarkSweepDeadRatio)) {
+FLAG_SET_DEFAULT(MarkSweepDeadRatio, 1);
 }
 }
 }
 void Arguments::set_g1_gc_flags() {
 if (ParallelGCThreads == 0) {
 FLAG_SET_DEFAULT(ParallelGCThreads,
 Abstract_VM_Version::parallel_worker_threads());
 }
-if (FLAG_IS_DEFAULT(MarkStackSize)) {
+// MarkStackSize will be set (if it hasn't been set by the user)
-FLAG_SET_DEFAULT(MarkStackSize, 128 * TASKQUEUE_SIZE);
+// when concurrent marking is initialized.
-}
+// Its value will be based upon the number of parallel marking threads.
-if (PrintGCDetails && Verbose) {
+// But we do set the maximum mark stack size here.
-tty->print_cr("MarkStackSize: %uk  MarkStackSizeMax: %uk",
+if (FLAG_IS_DEFAULT(MarkStackSizeMax)) {
-MarkStackSize / K, MarkStackSizeMax / K);
+FLAG_SET_DEFAULT(MarkStackSizeMax, 128 * TASKQUEUE_SIZE);
-tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
 }
 if (FLAG_IS_DEFAULT(GCTimeRatio) || GCTimeRatio == 0) {
 // In G1, we want the default GC overhead goal to be higher than
 // say in PS. So we set it here to 10%. Otherwise the heap might
 // be expanded more aggressively than we would like it to. In
 // fact, even 10% seems to not be high enough in some cases
 // (especially small GC stress tests that the main thing they do
 // is allocation). We might consider increase it further.
 FLAG_SET_DEFAULT(GCTimeRatio, 9);
+}
+if (PrintGCDetails && Verbose) {
+tty->print_cr("MarkStackSize: %uk  MarkStackSizeMax: %uk",
+MarkStackSize / K, MarkStackSizeMax / K);
+tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
 }
 }
 void Arguments::set_heap_size() {
 if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) {
 }
 return status;
 }
+void Arguments::check_deprecated_gcs() {
+if (UseConcMarkSweepGC && !UseParNewGC) {
+warning("Using the DefNew young collector with the CMS collector is deprecated "
+"and will likely be removed in a future release");
+}
+if (UseParNewGC && !UseConcMarkSweepGC) {
+// !UseConcMarkSweepGC means that we are using serial old gc. Unfortunately we don't
+// set up UseSerialGC properly, so that can't be used in the check here.
+warning("Using the ParNew young collector with the Serial old collector is deprecated "
+"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");
+}
+}
 // Check stack pages settings
 bool Arguments::check_stack_pages()
 {
 bool status = true;
 status = status && verify_min_value(StackYellowPages, 1, "StackYellowPages");
 status = status && verify_object_alignment();
 status = status && verify_min_value(ClassMetaspaceSize, 1*M,
 "ClassMetaspaceSize");
+status = status && verify_interval(MarkStackSizeMax,
+1, (max_jint - 1), "MarkStackSizeMax");
 #ifdef SPARC
 if (UseConcMarkSweepGC || UseG1GC) {
 // Issue a stern warning if the user has explicitly set
 // UseMemSetInBOT (it is known to cause issues), but allow
 // Disable large pages to allow shared spaces.  This is sub-optimal, since
 // there may not even be a shared archive to use.
 FLAG_SET_DEFAULT(UseLargePages, false);
 }
-// Add 2M to any size for SharedReadOnlySize to get around the JPRT setting
-if (DumpSharedSpaces && !FLAG_IS_DEFAULT(SharedReadOnlySize)) {
-SharedReadOnlySize = 14*M;
-}
 if (DumpSharedSpaces) {
 if (RequireSharedSpaces) {
 warning("cannot dump shared archive while using shared archive");
 }
 UseSharedSpaces = false;
 strlen(os::file_separator()) + 20, mtInternal);
 if (shared_archive_path == NULL) return JNI_ENOMEM;
 strcpy(shared_archive_path, jvm_path);
 strcat(shared_archive_path, os::file_separator());
 strcat(shared_archive_path, "classes");
-DEBUG_ONLY(strcat(shared_archive_path, "_g");)
 strcat(shared_archive_path, ".jsa");
 SharedArchivePath = shared_archive_path;
 // Remaining part of option string
 const char* tail;
 } else if (UseParNewGC) {  // skipped if CMS is set above
 set_parnew_gc_flags();
 } else if (UseG1GC) {
 set_g1_gc_flags();
 }
+check_deprecated_gcs();
 #endif // INCLUDE_ALTERNATE_GCS
 #ifdef SERIALGC
 assert(verify_serial_gc_flags(), "SerialGC unset");
 #endif // SERIALGC
 UseOptoBiasInlining = false;
 }
 if (!EliminateLocks) {
 EliminateNestedLocks = false;
 }
+if (!Inline) {
+IncrementalInline = false;
+}
+#ifndef PRODUCT
+if (!IncrementalInline) {
+AlwaysIncrementalInline = false;
+}
+#endif
+if (IncrementalInline && FLAG_IS_DEFAULT(MaxNodeLimit)) {
+// incremental inlining: bump MaxNodeLimit
+FLAG_SET_DEFAULT(MaxNodeLimit, (intx)75000);
+}
 #endif
 if (PrintAssembly && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
 warning("PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output");
 DebugNonSafepoints = true;

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/arguments.cpp @ 7482:989155e2d07a