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

comparison src/share/vm/runtime/arguments.cpp @ 360:5d254928c888

Merge

author	ysr
date	Wed, 27 Aug 2008 11:20:46 -0700
parents	1ee8caae33af
children	032ddb9432ad

comparison

equal deleted inserted replaced

-:d60e4e6d7f72
+:5d254928c888
 // 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 && !UseParallelGC, "control point invariant");
+assert(!UseSerialGC && !UseParallelGC && !UseG1GC,
+"control point invariant");
+assert(UseParNewGC, "Error");
 // Turn off AdaptiveSizePolicy by default for parnew until it is
 // complete.
-if (UseParNewGC &&
+if (FLAG_IS_DEFAULT(UseAdaptiveSizePolicy)) {
-FLAG_IS_DEFAULT(UseAdaptiveSizePolicy)) {
 FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false);
 }
-if (FLAG_IS_DEFAULT(UseParNewGC) && ParallelGCThreads > 1) {
+if (ParallelGCThreads == 0) {
-FLAG_SET_DEFAULT(UseParNewGC, true);
-} else if (UseParNewGC && ParallelGCThreads == 0) {
 FLAG_SET_DEFAULT(ParallelGCThreads,
 Abstract_VM_Version::parallel_worker_threads());
 if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) {
 FLAG_SET_DEFAULT(UseParNewGC, false);
 }
 // 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
 // certainly gain from analysis of platform and environment.
 void Arguments::set_cms_and_parnew_gc_flags() {
-if (UseSerialGC || UseParallelGC) {
+assert(!UseSerialGC && !UseParallelGC, "Error");
-return;
-}
 assert(UseConcMarkSweepGC, "CMS is expected to be on here");
 // If we are using CMS, we prefer to UseParNewGC,
 // unless explicitly forbidden.
-if (!UseParNewGC && FLAG_IS_DEFAULT(UseParNewGC)) {
+if (FLAG_IS_DEFAULT(UseParNewGC)) {
 FLAG_SET_ERGO(bool, UseParNewGC, true);
 }
 // Turn off AdaptiveSizePolicy by default for cms until it is
 // complete.
 // If no other collector is requested explicitly,
 // let the VM select the collector based on
 // machine class and automatic selection policy.
 if (!UseSerialGC &&
 !UseConcMarkSweepGC &&
+!UseG1GC &&
 !UseParNewGC &&
 !DumpSharedSpaces &&
 FLAG_IS_DEFAULT(UseParallelGC)) {
 if (should_auto_select_low_pause_collector()) {
 FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true);
 // Compressed Headers do not work with CMS, which uses a bit in the klass
 // field offset to determine free list chunk markers.
 // Check that UseCompressedOops can be set with the max heap size allocated
 // by ergonomics.
 if (MaxHeapSize <= max_heap_for_compressed_oops()) {
-if (FLAG_IS_DEFAULT(UseCompressedOops)) {
+if (FLAG_IS_DEFAULT(UseCompressedOops) && !UseG1GC) {
 // Turn off until bug is fixed.
+// the following line to return it to default status.
 // FLAG_SET_ERGO(bool, UseCompressedOops, true);
+} else if (UseCompressedOops && UseG1GC) {
+warning(" UseCompressedOops does not currently work with UseG1GC; switching off UseCompressedOops. ");
+FLAG_SET_DEFAULT(UseCompressedOops, false);
 }
 } else {
 if (UseCompressedOops && !FLAG_IS_DEFAULT(UseCompressedOops)) {
-// If specified, give a warning
+warning("Max heap size too large for Compressed Oops");
-if (UseConcMarkSweepGC){
-warning("Compressed Oops does not work with CMS");
-} else {
-warning(
-"Max heap size too large for Compressed Oops");
-}
 FLAG_SET_DEFAULT(UseCompressedOops, false);
 }
 }
 // Also checks that certain machines are slower with compressed oops
 // in vm_version initialization code.
 #endif // _LP64
 }
 void Arguments::set_parallel_gc_flags() {
+assert(UseParallelGC || UseParallelOldGC, "Error");
 // If parallel old was requested, automatically enable parallel scavenge.
 if (UseParallelOldGC && !UseParallelGC && FLAG_IS_DEFAULT(UseParallelGC)) {
 FLAG_SET_DEFAULT(UseParallelGC, true);
 }
 // 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)) {
+// PS is a server collector, setup the heap sizes accordingly.
-const uint64_t reasonable_fraction =
+set_server_heap_size();
-os::physical_memory() / DefaultMaxRAMFraction;
-const uint64_t maximum_size = (uint64_t)
-(FLAG_IS_DEFAULT(DefaultMaxRAM) && UseCompressedOops ?
-MIN2(max_heap_for_compressed_oops(), DefaultMaxRAM) :
-DefaultMaxRAM);
-size_t reasonable_max =
-(size_t) os::allocatable_physical_memory(reasonable_fraction);
-if (reasonable_max > maximum_size) {
-reasonable_max = maximum_size;
-}
-if (PrintGCDetails && Verbose) {
-// Cannot use gclog_or_tty yet.
-tty->print_cr("  Max heap size for server class platform "
-SIZE_FORMAT, reasonable_max);
-}
-// If the initial_heap_size has not been set with -Xms,
-// then set it as fraction of size of physical memory
-// respecting the maximum and minimum sizes of the heap.
-if (initial_heap_size() == 0) {
-const uint64_t reasonable_initial_fraction =
-os::physical_memory() / DefaultInitialRAMFraction;
-const size_t reasonable_initial =
-(size_t) os::allocatable_physical_memory(reasonable_initial_fraction);
-const size_t minimum_size = NewSize + OldSize;
-set_initial_heap_size(MAX2(MIN2(reasonable_initial, reasonable_max),
-minimum_size));
-// Currently the minimum size and the initial heap sizes are the same.
-set_min_heap_size(initial_heap_size());
-if (PrintGCDetails && Verbose) {
-// Cannot use gclog_or_tty yet.
-tty->print_cr("  Initial heap size for server class platform "
-SIZE_FORMAT, initial_heap_size());
-}
-} else {
-// An minimum size was specified on the command line.  Be sure
-// that the maximum size is consistent.
-if (initial_heap_size() > reasonable_max) {
-reasonable_max = initial_heap_size();
-}
-}
-FLAG_SET_ERGO(uintx, MaxHeapSize, (uintx) reasonable_max);
-}
 // 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.
 if (!FLAG_IS_DEFAULT(SurvivorRatio)) {
 }
 }
 }
 }
+void Arguments::set_g1_gc_flags() {
+assert(UseG1GC, "Error");
+// G1 is a server collector, setup the heap sizes accordingly.
+set_server_heap_size();
+#ifdef COMPILER1
+FastTLABRefill = false;
+#endif
+FLAG_SET_DEFAULT(ParallelGCThreads,
+Abstract_VM_Version::parallel_worker_threads());
+if (ParallelGCThreads == 0) {
+FLAG_SET_DEFAULT(ParallelGCThreads,
+Abstract_VM_Version::parallel_worker_threads
+());
+}
+no_shared_spaces();
+}
+void Arguments::set_server_heap_size() {
+if (FLAG_IS_DEFAULT(MaxHeapSize)) {
+const uint64_t reasonable_fraction =
+os::physical_memory() / DefaultMaxRAMFraction;
+const uint64_t maximum_size = (uint64_t)
+(FLAG_IS_DEFAULT(DefaultMaxRAM) && UseCompressedOops ?
+MIN2(max_heap_for_compressed_oops(), DefaultMaxRAM) :
+DefaultMaxRAM);
+size_t reasonable_max =
+(size_t) os::allocatable_physical_memory(reasonable_fraction);
+if (reasonable_max > maximum_size) {
+reasonable_max = maximum_size;
+}
+if (PrintGCDetails && Verbose) {
+// Cannot use gclog_or_tty yet.
+tty->print_cr("  Max heap size for server class platform "
+SIZE_FORMAT, reasonable_max);
+}
+// If the initial_heap_size has not been set with -Xms,
+// then set it as fraction of size of physical memory
+// respecting the maximum and minimum sizes of the heap.
+if (initial_heap_size() == 0) {
+const uint64_t reasonable_initial_fraction =
+os::physical_memory() / DefaultInitialRAMFraction;
+const size_t reasonable_initial =
+(size_t) os::allocatable_physical_memory(reasonable_initial_fraction);
+const size_t minimum_size = NewSize + OldSize;
+set_initial_heap_size(MAX2(MIN2(reasonable_initial, reasonable_max),
+minimum_size));
+// Currently the minimum size and the initial heap sizes are the same.
+set_min_heap_size(initial_heap_size());
+if (PrintGCDetails && Verbose) {
+// Cannot use gclog_or_tty yet.
+tty->print_cr("  Initial heap size for server class platform "
+SIZE_FORMAT, initial_heap_size());
+}
+} else {
+// A minimum size was specified on the command line.  Be sure
+// that the maximum size is consistent.
+if (initial_heap_size() > reasonable_max) {
+reasonable_max = initial_heap_size();
+}
+}
+FLAG_SET_ERGO(uintx, MaxHeapSize, (uintx) reasonable_max);
+}
+}
 // This must be called after ergonomics because we want bytecode rewriting
 // if the server compiler is used, or if UseSharedSpaces is disabled.
 void Arguments::set_bytecode_flags() {
 // Better not attempt to store into a read-only space.
 if (UseSharedSpaces) {
 FLAG_SET_DEFAULT(UseSerialGC, true);
 FLAG_SET_DEFAULT(UseParNewGC, false);
 FLAG_SET_DEFAULT(UseConcMarkSweepGC, false);
 FLAG_SET_DEFAULT(UseParallelGC, false);
 FLAG_SET_DEFAULT(UseParallelOldGC, false);
+FLAG_SET_DEFAULT(UseG1GC, false);
 }
 static bool verify_serial_gc_flags() {
 return (UseSerialGC &&
-!(UseParNewGC || UseConcMarkSweepGC || UseParallelGC ||
+!(UseParNewGC || UseConcMarkSweepGC || UseG1GC ||
-UseParallelOldGC));
+UseParallelGC || UseParallelOldGC));
 }
 // Check consistency of GC selection
 bool Arguments::check_gc_consistency() {
 bool status = true;
 }
 status = status && verify_percentage(GCHeapFreeLimit, "GCHeapFreeLimit");
 // Check user specified sharing option conflict with Parallel GC
-bool cannot_share = (UseConcMarkSweepGC || UseParallelGC ||
+bool cannot_share = (UseConcMarkSweepGC || UseG1GC || UseParNewGC ||
-UseParallelOldGC || UseParNewGC ||
+UseParallelGC || UseParallelOldGC ||
 SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages));
 if (cannot_share) {
 // Either force sharing on by forcing the other options off, or
 // force sharing off.
 if (!UseConcMarkSweepGC) {
 jio_fprintf(defaultStream::error_stream(),
 "error:  invalid argument combination.\n"
 "The CMS collector (-XX:+UseConcMarkSweepGC) must be "
 "selected in order\nto use CMSIncrementalMode.\n");
-status = false;
-} else if (!UseTLAB) {
-jio_fprintf(defaultStream::error_stream(),
-"error:  CMSIncrementalMode requires thread-local "
-"allocation buffers\n(-XX:+UseTLAB).\n");
 status = false;
 } else {
 status = status && verify_percentage(CMSIncrementalDutyCycle,
 "CMSIncrementalDutyCycle");
 status = status && verify_percentage(CMSIncrementalDutyCycleMin,
 // CMSInitiatingOccupancyFraction to 1 so icms can initiate cycles early.
 if (CMSInitiatingOccupancyFraction < 0) {
 FLAG_SET_DEFAULT(CMSInitiatingOccupancyFraction, 1);
 }
 }
-}
-if (UseNUMA && !UseTLAB) {
-jio_fprintf(defaultStream::error_stream(),
-"error:  NUMA allocator (-XX:+UseNUMA) requires thread-local "
-"allocation\nbuffers (-XX:+UseTLAB).\n");
-status = false;
 }
 // CMS space iteration, which FLSVerifyAllHeapreferences entails,
 // insists that we hold the requisite locks so that the iteration is
 // MT-safe. For the verification at start-up and shut-down, we don't
 // 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));
 }
 #else
 if (!FLAG_IS_DEFAULT(OptoLoopAlignment) && FLAG_IS_DEFAULT(MaxLoopPad)) {
 FLAG_SET_DEFAULT(MaxLoopPad, OptoLoopAlignment-1);
+}
+// Temporary disable bulk zeroing reduction with G1. See CR 6627983.
+if (UseG1GC) {
+FLAG_SET_DEFAULT(ReduceBulkZeroing, false);
 }
 #endif
 if (!check_vm_args_consistency()) {
 return JNI_ERR;
 logOption(tail);
 }
 }
 }
 // Parse JavaVMInitArgs structure passed in, as well as JAVA_TOOL_OPTIONS and _JAVA_OPTIONS
 jint result = parse_vm_init_args(args);
 if (result != JNI_OK) {
 return result;
+}
+// These are hacks until G1 is fully supported and tested
+// but lets you force -XX:+UseG1GC in PRT and get it where it (mostly) works
+if (UseG1GC) {
+if (UseConcMarkSweepGC || UseParNewGC || UseParallelGC || UseParallelOldGC || UseSerialGC) {
+#ifndef PRODUCT
+tty->print_cr("-XX:+UseG1GC is incompatible with other collectors, using UseG1GC");
+#endif // PRODUCT
+UseConcMarkSweepGC = false;
+UseParNewGC        = false;
+UseParallelGC      = false;
+UseParallelOldGC   = false;
+UseSerialGC        = false;
+}
+no_shared_spaces();
 }
 #ifndef PRODUCT
 if (TraceBytecodesAt != 0) {
 TraceBytecodes = true;
 // Set some flags for CMS
 set_cms_and_parnew_gc_flags();
 } else if (UseParNewGC) {
 // Set some flags for ParNew
 set_parnew_gc_flags();
+}
+// Temporary; make the "if" an "else-if" before
+// we integrate G1. XXX
+if (UseG1GC) {
+// Set some flags for garbage-first, if needed.
+set_g1_gc_flags();
 }
 #ifdef SERIALGC
 assert(verify_serial_gc_flags(), "SerialGC unset");
 #endif // SERIALGC

Mercurial > hg > truffle

comparison src/share/vm/runtime/arguments.cpp @ 360:5d254928c888