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

comparison src/share/vm/runtime/arguments.cpp @ 10:28372612af5e

6362677: Change parallel GC collector default number of parallel GC threads. Summary: Use the same default number of GC threads as used by ParNewGC and ConcMarkSweepGC (i.e., the 5/8th rule). Reviewed-by: ysr, tonyp

author	jmasa
date	Fri, 22 Feb 2008 17:17:14 -0800
parents	a61af66fc99e
children	183f41cf8bfe

comparison

equal deleted inserted replaced

-:173195ff483a
+:28372612af5e
 // UseParNewGC and not explicitly set ParallelGCThreads we
 // set it, unless this is a single cpu machine.
 void Arguments::set_parnew_gc_flags() {
 assert(!UseSerialGC && !UseParallelGC, "control point invariant");
+// Turn off AdaptiveSizePolicy by default for parnew until it is
+// complete.
+if (UseParNewGC &&
+FLAG_IS_DEFAULT(UseAdaptiveSizePolicy)) {
+FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false);
+}
 if (FLAG_IS_DEFAULT(UseParNewGC) && ParallelGCThreads > 1) {
 FLAG_SET_DEFAULT(UseParNewGC, true);
 } else if (UseParNewGC && ParallelGCThreads == 0) {
-FLAG_SET_DEFAULT(ParallelGCThreads, nof_parallel_gc_threads());
+FLAG_SET_DEFAULT(ParallelGCThreads,
+Abstract_VM_Version::parallel_worker_threads());
 if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) {
 FLAG_SET_DEFAULT(UseParNewGC, false);
 }
 }
 if (!UseParNewGC) {
 // AlwaysTenure flag should make ParNew to promote all at first collection.
 // See CR 6362902.
 if (AlwaysTenure) {
 FLAG_SET_CMDLINE(intx, MaxTenuringThreshold, 0);
 }
-}
-}
-// CAUTION: this code is currently shared by UseParallelGC, UseParNewGC and
-// UseconcMarkSweepGC. Further tuning of individual collectors might
-// dictate refinement on a per-collector basis.
-int Arguments::nof_parallel_gc_threads() {
-if (FLAG_IS_DEFAULT(ParallelGCThreads)) {
-// For very large machines, there are diminishing returns
-// for large numbers of worker threads.  Instead of
-// hogging the whole system, use 5/8ths of a worker for every
-// processor after the first 8.  For example, on a 72 cpu
-// machine use 8 + (72 - 8) * (5/8) == 48 worker threads.
-// This is just a start and needs further tuning and study in
-// Tiger.
-int ncpus = os::active_processor_count();
-return (ncpus <= 8) ? ncpus : 3 + ((ncpus * 5) / 8);
-} else {
-return ParallelGCThreads;
 }
 }
 // Adjust some sizes to suit CMS and/or ParNew needs; these work well on
 // sparc/solaris for certain applications, but would gain from
 void Arguments::set_cms_and_parnew_gc_flags() {
 if (UseSerialGC || UseParallelGC) {
 return;
 }
+assert(UseConcMarkSweepGC, "CMS is expected to be on here");
 // If we are using CMS, we prefer to UseParNewGC,
 // unless explicitly forbidden.
-if (UseConcMarkSweepGC && !UseParNewGC && FLAG_IS_DEFAULT(UseParNewGC)) {
+if (!UseParNewGC && FLAG_IS_DEFAULT(UseParNewGC)) {
-FLAG_SET_DEFAULT(UseParNewGC, true);
+FLAG_SET_ERGO(bool, UseParNewGC, true);
 }
 // Turn off AdaptiveSizePolicy by default for cms until it is
-// complete.  Also turn it off in general if the
+// complete.
-// parnew collector has been selected.
+if (FLAG_IS_DEFAULT(UseAdaptiveSizePolicy)) {
-if ((UseConcMarkSweepGC || UseParNewGC) &&
-FLAG_IS_DEFAULT(UseAdaptiveSizePolicy)) {
 FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false);
 }
 // In either case, adjust ParallelGCThreads and/or UseParNewGC
 // as needed.
-set_parnew_gc_flags();
+if (UseParNewGC) {
+set_parnew_gc_flags();
-if (!UseConcMarkSweepGC) {
-return;
 }
 // Now make adjustments for CMS
 size_t young_gen_per_worker;
 intx new_ratio;
 !UseParNewGC &&
 !DumpSharedSpaces &&
 FLAG_IS_DEFAULT(UseParallelGC)) {
 if (should_auto_select_low_pause_collector()) {
 FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true);
-set_cms_and_parnew_gc_flags();
 } else {
 FLAG_SET_ERGO(bool, UseParallelGC, true);
 }
 no_shared_spaces();
 }
-// This is here because the parallel collector could
-// have been selected so this initialization should
-// still be done.
-set_parallel_gc_flags();
 }
 }
 void Arguments::set_parallel_gc_flags() {
 // If parallel old was requested, automatically enable parallel scavenge.
 }
 // 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_ERGO(uintx, ParallelGCThreads,
+Abstract_VM_Version::parallel_worker_threads());
 if (FLAG_IS_DEFAULT(MaxHeapSize)) {
 const uint64_t reasonable_fraction =
 os::physical_memory() / DefaultMaxRAMFraction;
 const uint64_t maximum_size = (uint64_t) DefaultMaxRAM;
 size_t reasonable_max =
 return (UseSerialGC &&
 !(UseParNewGC || UseConcMarkSweepGC || UseParallelGC ||
 UseParallelOldGC));
 }
-// Check the consistency of vm_init_args
+// Check consistency of GC selection
-bool Arguments::check_vm_args_consistency() {
+bool Arguments::check_gc_consistency() {
-// Method for adding checks for flag consistency.
-// 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(),
-"-UseStackBanging conflicts with -UseBoundThreads\n");
-status = false;
-}
-#endif
-if (TLABRefillWasteFraction == 0) {
-jio_fprintf(defaultStream::error_stream(),
-"TLABRefillWasteFraction should be a denominator, "
-"not " SIZE_FORMAT "\n",
-TLABRefillWasteFraction);
-status = false;
-}
-status &= verify_percentage(MaxLiveObjectEvacuationRatio,
-"MaxLiveObjectEvacuationRatio");
-status &= verify_percentage(AdaptiveSizePolicyWeight,
-"AdaptiveSizePolicyWeight");
-status &= verify_percentage(AdaptivePermSizeWeight, "AdaptivePermSizeWeight");
-status &= verify_percentage(ThresholdTolerance, "ThresholdTolerance");
-status &= verify_percentage(MinHeapFreeRatio, "MinHeapFreeRatio");
-status &= verify_percentage(MaxHeapFreeRatio, "MaxHeapFreeRatio");
-if (MinHeapFreeRatio > MaxHeapFreeRatio) {
-jio_fprintf(defaultStream::error_stream(),
-"MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
-"equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
-MinHeapFreeRatio, MaxHeapFreeRatio);
-status = false;
-}
-// Keeping the heap 100% free is hard ;-) so limit it to 99%.
-MinHeapFreeRatio = MIN2(MinHeapFreeRatio, (uintx) 99);
-if (FullGCALot && FLAG_IS_DEFAULT(MarkSweepAlwaysCompactCount)) {
-MarkSweepAlwaysCompactCount = 1;  // Move objects every gc.
-}
-status &= verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit");
-status &= verify_percentage(GCTimeLimit, "GCTimeLimit");
-if (GCTimeLimit == 100) {
-// Turn off gc-overhead-limit-exceeded checks
-FLAG_SET_DEFAULT(UseGCOverheadLimit, false);
-}
-status &= verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit");
-// Check user specified sharing option conflict with Parallel GC
-bool cannot_share = (UseConcMarkSweepGC || UseParallelGC ||
-UseParallelOldGC || UseParNewGC ||
-SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages));
-if (cannot_share) {
-// Either force sharing on by forcing the other options off, or
-// force sharing off.
-if (DumpSharedSpaces || ForceSharedSpaces) {
-set_serial_gc_flags();
-FLAG_SET_DEFAULT(SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages), false);
-} else {
-no_shared_spaces();
-}
-}
 // Ensure that the user has not selected conflicting sets
 // of collectors. [Note: this check is merely a user convenience;
 // collectors over-ride each other so that only a non-conflicting
 // set is selected; however what the user gets is not what they
 // may have expected from the combination they asked for. It's
 "please refer to the release notes for the combinations "
 "allowed\n");
 status = false;
 }
+return status;
+}
+// Check the consistency of vm_init_args
+bool Arguments::check_vm_args_consistency() {
+// Method for adding checks for flag consistency.
+// 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(),
+"-UseStackBanging conflicts with -UseBoundThreads\n");
+status = false;
+}
+#endif
+if (TLABRefillWasteFraction == 0) {
+jio_fprintf(defaultStream::error_stream(),
+"TLABRefillWasteFraction should be a denominator, "
+"not " SIZE_FORMAT "\n",
+TLABRefillWasteFraction);
+status = false;
+}
+status = status && verify_percentage(MaxLiveObjectEvacuationRatio,
+"MaxLiveObjectEvacuationRatio");
+status = status && verify_percentage(AdaptiveSizePolicyWeight,
+"AdaptiveSizePolicyWeight");
+status = status && verify_percentage(AdaptivePermSizeWeight, "AdaptivePermSizeWeight");
+status = status && verify_percentage(ThresholdTolerance, "ThresholdTolerance");
+status = status && verify_percentage(MinHeapFreeRatio, "MinHeapFreeRatio");
+status = status && verify_percentage(MaxHeapFreeRatio, "MaxHeapFreeRatio");
+if (MinHeapFreeRatio > MaxHeapFreeRatio) {
+jio_fprintf(defaultStream::error_stream(),
+"MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
+"equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
+MinHeapFreeRatio, MaxHeapFreeRatio);
+status = false;
+}
+// Keeping the heap 100% free is hard ;-) so limit it to 99%.
+MinHeapFreeRatio = MIN2(MinHeapFreeRatio, (uintx) 99);
+if (FullGCALot && FLAG_IS_DEFAULT(MarkSweepAlwaysCompactCount)) {
+MarkSweepAlwaysCompactCount = 1;  // Move objects every gc.
+}
+status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit");
+status = status && verify_percentage(GCTimeLimit, "GCTimeLimit");
+if (GCTimeLimit == 100) {
+// Turn off gc-overhead-limit-exceeded checks
+FLAG_SET_DEFAULT(UseGCOverheadLimit, false);
+}
+status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit");
+// Check user specified sharing option conflict with Parallel GC
+bool cannot_share = (UseConcMarkSweepGC || UseParallelGC ||
+UseParallelOldGC || UseParNewGC ||
+SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages));
+if (cannot_share) {
+// Either force sharing on by forcing the other options off, or
+// force sharing off.
+if (DumpSharedSpaces || ForceSharedSpaces) {
+set_serial_gc_flags();
+FLAG_SET_DEFAULT(SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages), false);
+} else {
+no_shared_spaces();
+}
+}
+status = status && check_gc_consistency();
 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 "
 jio_fprintf(defaultStream::error_stream(),
 "error:  CMSIncrementalMode requires thread-local "
 "allocation buffers\n(-XX:+UseTLAB).\n");
 status = false;
 } else {
-status &= verify_percentage(CMSIncrementalDutyCycle,
+status = status && verify_percentage(CMSIncrementalDutyCycle,
 "CMSIncrementalDutyCycle");
-status &= verify_percentage(CMSIncrementalDutyCycleMin,
+status = status && verify_percentage(CMSIncrementalDutyCycleMin,
 "CMSIncrementalDutyCycleMin");
-status &= verify_percentage(CMSIncrementalSafetyFactor,
+status = status && verify_percentage(CMSIncrementalSafetyFactor,
 "CMSIncrementalSafetyFactor");
-status &= verify_percentage(CMSIncrementalOffset,
+status = status && verify_percentage(CMSIncrementalOffset,
 "CMSIncrementalOffset");
-status &= verify_percentage(CMSExpAvgFactor,
+status = status && verify_percentage(CMSExpAvgFactor,
 "CMSExpAvgFactor");
 // If it was not set on the command line, set
 // CMSInitiatingOccupancyFraction to 1 so icms can initiate cycles early.
 if (CMSInitiatingOccupancyFraction < 0) {
 FLAG_SET_DEFAULT(CMSInitiatingOccupancyFraction, 1);
 // See runtime/compilationPolicy.*.
 FLAG_SET_CMDLINE(intx, CompilationPolicyChoice, 0);
 // Enable parallel GC and adaptive generation sizing
 FLAG_SET_CMDLINE(bool, UseParallelGC, true);
-FLAG_SET_DEFAULT(ParallelGCThreads, nof_parallel_gc_threads());
+FLAG_SET_DEFAULT(ParallelGCThreads,
+Abstract_VM_Version::parallel_worker_threads());
 // Encourage steady state memory management
 FLAG_SET_CMDLINE(uintx, ThresholdTolerance, 100);
 // This appears to improve mutator locality
 #endif // SERIALGC
 #ifdef KERNEL
 no_shared_spaces();
 #endif // KERNEL
-// Set some flags for ParallelGC if needed.
-set_parallel_gc_flags();
-// Set some flags for CMS and/or ParNew collectors, as needed.
-set_cms_and_parnew_gc_flags();
 // Set flags based on ergonomics.
 set_ergonomics_flags();
+// Check the GC selections again.
+if (!check_gc_consistency()) {
+return JNI_EINVAL;
+}
+if (UseParallelGC) {
+// Set some flags for ParallelGC if needed.
+set_parallel_gc_flags();
+} else if (UseConcMarkSweepGC) {
+// Set some flags for CMS
+set_cms_and_parnew_gc_flags();
+} else if (UseParNewGC) {
+// Set some flags for ParNew
+set_parnew_gc_flags();
+}
 #ifdef SERIALGC
 assert(verify_serial_gc_flags(), "SerialGC unset");
 #endif // SERIALGC
 #endif /* CC_INTERP */
 if (PrintCommandLineFlags) {
 CommandLineFlags::printSetFlags();
 }
+#ifdef ASSERT
+if (PrintFlagsFinal) {
+CommandLineFlags::printFlags();
+}
+#endif
 return JNI_OK;
 }
 int Arguments::PropertyList_count(SystemProperty* pl) {

Mercurial > hg > truffle

comparison src/share/vm/runtime/arguments.cpp @ 10:28372612af5e