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

comparison src/share/vm/runtime/arguments.cpp @ 1064:473cce303f13

6887571: Increase default heap config sizes Summary: Apply modification of existing server heap size ergo to all collectors except CMS. Reviewed-by: jmasa, ysr, xlu

author	phh
date	Wed, 28 Oct 2009 16:25:51 -0400
parents	354d3184f6b2
children	fb4c00faa9da

comparison

equal deleted inserted replaced

-:a3b9e96881fe
+:473cce303f13
 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::_initial_heap_size            = 0;
 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;
 { "MaxTickInterval",               JDK_Version::jdk(5), JDK_Version::jdk(7) },
 { "DelayTickAdjustment",           JDK_Version::jdk(5), JDK_Version::jdk(7) },
 { "ProcessingToTenuringRatio",     JDK_Version::jdk(5), JDK_Version::jdk(7) },
 { "MinTrainLength",                JDK_Version::jdk(5), JDK_Version::jdk(7) },
 { "AppendRatio",         JDK_Version::jdk_update(6,10), JDK_Version::jdk(7) },
+{ "DefaultMaxRAM",       JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },
+{ "DefaultInitialRAMFraction",
+JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },
 { NULL, JDK_Version(0), JDK_Version(0) }
 };
 // Returns true if the flag is obsolete and fits into the range specified
 // for being ignored.  In the case that the flag is ignored, the 'version'
 }
 uintx uintx_v = (uintx) v;
 if (!is_neg && CommandLineFlags::uintxAtPut(name, &uintx_v, origin)) {
 return true;
 }
+uint64_t uint64_t_v = (uint64_t) v;
+if (!is_neg && CommandLineFlags::uint64_tAtPut(name, &uint64_t_v, origin)) {
+return true;
+}
 return false;
 }
 static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) {
 if (!CommandLineFlags::ccstrAtPut(name, &value, origin))  return 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 && !UseParallelGC && !UseG1GC,
+assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC && !UseG1GC,
 "control point invariant");
 assert(UseParNewGC, "Error");
 // Turn off AdaptiveSizePolicy by default for parnew until it is
 // complete.
 }
 if (ParallelGCThreads == 0) {
 FLAG_SET_DEFAULT(ParallelGCThreads,
 Abstract_VM_Version::parallel_worker_threads());
-if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) {
+if (ParallelGCThreads == 1) {
 FLAG_SET_DEFAULT(UseParNewGC, false);
-}
+FLAG_SET_DEFAULT(ParallelGCThreads, 0);
 }
-if (!UseParNewGC) {
+}
-FLAG_SET_DEFAULT(ParallelGCThreads, 0);
+if (UseParNewGC) {
-} else {
+// CDS doesn't work with ParNew yet
 no_shared_spaces();
 // 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.
 }
 if (FLAG_IS_DEFAULT(OldPLABSize)) {
 FLAG_SET_DEFAULT(OldPLABSize, (intx)1024);
 }
-// AlwaysTenure flag should make ParNew to promote all at first collection.
+// AlwaysTenure flag should make ParNew promote all at first collection.
 // See CR 6362902.
 if (AlwaysTenure) {
 FLAG_SET_CMDLINE(intx, MaxTenuringThreshold, 0);
 }
 // When using compressed oops, we use local overflow stacks,
 // 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() {
-assert(!UseSerialGC && !UseParallelGC, "Error");
+assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC, "Error");
 assert(UseConcMarkSweepGC, "CMS is expected to be on here");
 // If we are using CMS, we prefer to UseParNewGC,
 // unless explicitly forbidden.
 if (FLAG_IS_DEFAULT(UseParNewGC)) {
 if (!FLAG_IS_DEFAULT(NewSize)) {   // NewSize explicitly set at command-line
 FLAG_SET_ERGO(uintx, MaxNewSize, MAX2(NewSize, preferred_max_new_size));
 } else {
 FLAG_SET_ERGO(uintx, MaxNewSize, preferred_max_new_size);
 }
-if(PrintGCDetails && Verbose) {
+if (PrintGCDetails && Verbose) {
 // Too early to use gclog_or_tty
 tty->print_cr("Ergo set MaxNewSize: " SIZE_FORMAT, MaxNewSize);
 }
 // Unless explicitly requested otherwise, prefer a large
 min_new = align_size_up(ScaleForWordSize(min_new_default),
 os::vm_page_size());
 } else {
 min_new = NewSize;
 }
-size_t prev_initial_size = initial_heap_size();
+size_t prev_initial_size = InitialHeapSize;
-if (prev_initial_size != 0 && prev_initial_size < min_new+OldSize) {
+if (prev_initial_size != 0 && prev_initial_size < min_new + OldSize) {
-set_initial_heap_size(min_new+OldSize);
+FLAG_SET_ERGO(uintx, InitialHeapSize, min_new + OldSize);
 // Currently minimum size and the initial heap sizes are the same.
-set_min_heap_size(initial_heap_size());
+set_min_heap_size(InitialHeapSize);
 if (PrintGCDetails && Verbose) {
 warning("Initial heap size increased to " SIZE_FORMAT " M from "
 SIZE_FORMAT " M; use -XX:NewSize=... for finer control.",
-initial_heap_size()/M, prev_initial_size/M);
+InitialHeapSize/M, prev_initial_size/M);
 }
 }
 // MaxHeapSize is aligned down in collectorPolicy
 size_t max_heap =
 align_size_down(MaxHeapSize,
 CardTableRS::ct_max_alignment_constraint());
-if(PrintGCDetails && Verbose) {
+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,
-min_heap_size(), initial_heap_size(), max_heap);
+min_heap_size(), InitialHeapSize, max_heap);
 }
 if (max_heap > min_new) {
 // Unless explicitly requested otherwise, make young gen
 // at least min_new, and at most preferred_max_new_size.
 if (FLAG_IS_DEFAULT(NewSize)) {
 FLAG_SET_ERGO(uintx, NewSize, MAX2(NewSize, min_new));
 FLAG_SET_ERGO(uintx, NewSize, MIN2(preferred_max_new_size, NewSize));
-if(PrintGCDetails && Verbose) {
+if (PrintGCDetails && Verbose) {
 // Too early to use gclog_or_tty
 tty->print_cr("Ergo set NewSize: " SIZE_FORMAT, NewSize);
 }
 }
 // Unless explicitly requested otherwise, size old gen
 // so that it's at least 3X of NewSize to begin with;
 // later NewRatio will decide how it grows; see above.
 if (FLAG_IS_DEFAULT(OldSize)) {
 if (max_heap > NewSize) {
-FLAG_SET_ERGO(uintx, OldSize, MIN2(3*NewSize,  max_heap - NewSize));
+FLAG_SET_ERGO(uintx, OldSize, MIN2(3*NewSize, max_heap - NewSize));
-if(PrintGCDetails && Verbose) {
+if (PrintGCDetails && Verbose) {
 // Too early to use gclog_or_tty
 tty->print_cr("Ergo set OldSize: " SIZE_FORMAT, OldSize);
 }
 }
 }
 }
 }
 inline uintx max_heap_for_compressed_oops() {
 LP64_ONLY(return oopDesc::OopEncodingHeapMax - MaxPermSize - os::vm_page_size());
-NOT_LP64(return DefaultMaxRAM);
+NOT_LP64(ShouldNotReachHere(); return 0);
 }
 bool Arguments::should_auto_select_low_pause_collector() {
 if (UseAutoGCSelectPolicy &&
 !FLAG_IS_DEFAULT(MaxGCPauseMillis) &&
 return false;
 }
 void Arguments::set_ergonomics_flags() {
 // Parallel GC is not compatible with sharing. If one specifies
-// that they want sharing explicitly, do not set ergonmics flags.
+// that they want sharing explicitly, do not set ergonomics flags.
 if (DumpSharedSpaces || ForceSharedSpaces) {
 return;
 }
 if (os::is_server_class_machine() && !force_client_mode ) {
 // of the physical memory, up to a maximum of 1GB.
 if (UseParallelGC) {
 FLAG_SET_ERGO(uintx, ParallelGCThreads,
 Abstract_VM_Version::parallel_worker_threads());
-// PS is a server collector, setup the heap sizes accordingly.
-set_server_heap_size();
 // 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 (FLAG_IS_DEFAULT(MaxGCPauseMillis)) {
 FLAG_SET_DEFAULT(MaxGCPauseMillis, 200);
 }
 }
-void Arguments::set_server_heap_size() {
+void Arguments::set_heap_size() {
+if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) {
+// Deprecated flag
+FLAG_SET_CMDLINE(uintx, MaxRAMFraction, DefaultMaxRAMFraction);
+}
+const julong phys_mem =
+FLAG_IS_DEFAULT(MaxRAM) ? MIN2(os::physical_memory(), (julong)MaxRAM)
+: (julong)MaxRAM;
+// If the maximum heap size has not been set with -Xmx,
+// then set it as fraction of the size of physical memory,
+// respecting the maximum and minimum sizes of the heap.
 if (FLAG_IS_DEFAULT(MaxHeapSize)) {
-const uint64_t reasonable_fraction =
+julong reasonable_max = phys_mem / MaxRAMFraction;
-os::physical_memory() / DefaultMaxRAMFraction;
-const uint64_t maximum_size = (uint64_t)
+if (phys_mem <= MaxHeapSize * MinRAMFraction) {
-(FLAG_IS_DEFAULT(DefaultMaxRAM) && UseCompressedOops ?
+// Small physical memory, so use a minimum fraction of it for the heap
-MIN2(max_heap_for_compressed_oops(), DefaultMaxRAM) :
+reasonable_max = phys_mem / MinRAMFraction;
-DefaultMaxRAM);
+} else {
-size_t reasonable_max =
+// Not-small physical memory, so require a heap at least
-(size_t) os::allocatable_physical_memory(reasonable_fraction);
+// as large as MaxHeapSize
-if (reasonable_max > maximum_size) {
+reasonable_max = MAX2(reasonable_max, (julong)MaxHeapSize);
-reasonable_max = maximum_size;
+}
-}
+if (!FLAG_IS_DEFAULT(ErgoHeapSizeLimit) && ErgoHeapSizeLimit != 0) {
+// Limit the heap size to ErgoHeapSizeLimit
+reasonable_max = MIN2(reasonable_max, (julong)ErgoHeapSizeLimit);
+}
+if (UseCompressedOops) {
+// Limit the heap size to the maximum possible when using compressed oops
+reasonable_max = MIN2(reasonable_max, (julong)max_heap_for_compressed_oops());
+}
+reasonable_max = os::allocatable_physical_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
+// method might reduce the allocation size.
+reasonable_max = MAX2(reasonable_max, (julong)InitialHeapSize);
+}
 if (PrintGCDetails && Verbose) {
 // Cannot use gclog_or_tty yet.
-tty->print_cr("  Max heap size for server class platform "
+tty->print_cr("  Maximum heap size " SIZE_FORMAT, reasonable_max);
-SIZE_FORMAT, reasonable_max);
+}
-}
+FLAG_SET_ERGO(uintx, MaxHeapSize, (uintx)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 the initial_heap_size has not been set with InitialHeapSize
-if (initial_heap_size() == 0) {
+// or -Xms, then set it as fraction of the size of physical memory,
-const uint64_t reasonable_initial_fraction =
+// respecting the maximum and minimum sizes of the heap.
-os::physical_memory() / DefaultInitialRAMFraction;
+if (FLAG_IS_DEFAULT(InitialHeapSize)) {
-const size_t reasonable_initial =
+julong reasonable_initial = phys_mem / InitialRAMFraction;
-(size_t) os::allocatable_physical_memory(reasonable_initial_fraction);
-const size_t minimum_size = NewSize + OldSize;
+reasonable_initial = MAX2(reasonable_initial, (julong)(OldSize + NewSize));
-set_initial_heap_size(MAX2(MIN2(reasonable_initial, reasonable_max),
+reasonable_initial = MIN2(reasonable_initial, (julong)MaxHeapSize);
-minimum_size));
-// Currently the minimum size and the initial heap sizes are the same.
+reasonable_initial = os::allocatable_physical_memory(reasonable_initial);
-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 "
+tty->print_cr("  Initial heap size " SIZE_FORMAT, (uintx)reasonable_initial);
-SIZE_FORMAT, initial_heap_size());
+}
-}
+FLAG_SET_ERGO(uintx, InitialHeapSize, (uintx)reasonable_initial);
-} else {
-// A minimum size was specified on the command line.  Be sure
+// Subsequent ergonomics code may expect min_heap_size to be set
-// that the maximum size is consistent.
+// if InitialHeapSize is.  Use whatever the current values are
-if (initial_heap_size() > reasonable_max) {
+// for OldSize and NewSize, whether or not they were set on the
-reasonable_max = initial_heap_size();
+// command line.
-}
+set_min_heap_size(OldSize + NewSize);
-}
-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.
 "%s of " UINTX_FORMAT " is invalid; must be between 0 and 100\n",
 name, value);
 return false;
 }
-static void set_serial_gc_flags() {
+static void force_serial_gc() {
 FLAG_SET_DEFAULT(UseSerialGC, true);
 FLAG_SET_DEFAULT(UseParNewGC, false);
 FLAG_SET_DEFAULT(UseConcMarkSweepGC, false);
 FLAG_SET_DEFAULT(CMSIncrementalMode, false);  // special CMS suboption
 FLAG_SET_DEFAULT(UseParallelGC, false);
 if (cannot_share) {
 // Either force sharing on by forcing the other options off, or
 // force sharing off.
 if (DumpSharedSpaces || ForceSharedSpaces) {
 jio_fprintf(defaultStream::error_stream(),
-"Reverting to Serial GC because of %s \n",
+"Reverting to Serial GC because of %s\n",
 ForceSharedSpaces ? " -Xshare:on" : "-Xshare:dump");
-set_serial_gc_flags();
+force_serial_gc();
 FLAG_SET_DEFAULT(SOLARIS_ONLY(UseISM) NOT_SOLARIS(UseLargePages), false);
 } else {
-if (UseSharedSpaces) {
+if (UseSharedSpaces && Verbose) {
 jio_fprintf(defaultStream::error_stream(),
 "Turning off use of shared archive because of "
-"choice of garbage collector or large pages \n");
+"choice of garbage collector or large pages\n");
 }
 no_shared_spaces();
 }
 }
 jio_fprintf(defaultStream::error_stream(),
 "Invalid initial eden size: %s\n", option->optionString);
 describe_range_error(errcode);
 return JNI_EINVAL;
 }
-FLAG_SET_CMDLINE(uintx, MaxNewSize, (size_t) long_initial_eden_size);
+FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_eden_size);
-FLAG_SET_CMDLINE(uintx, NewSize, (size_t) long_initial_eden_size);
+FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_eden_size);
 // -Xms
 } else if (match_option(option, "-Xms", &tail)) {
 julong long_initial_heap_size = 0;
 ArgsRange errcode = parse_memory_size(tail, &long_initial_heap_size, 1);
 if (errcode != arg_in_range) {
 jio_fprintf(defaultStream::error_stream(),
 "Invalid initial heap size: %s\n", option->optionString);
 describe_range_error(errcode);
 return JNI_EINVAL;
 }
-set_initial_heap_size((size_t) long_initial_heap_size);
+FLAG_SET_CMDLINE(uintx, InitialHeapSize, (uintx)long_initial_heap_size);
 // Currently the minimum size and the initial heap sizes are the same.
-set_min_heap_size(initial_heap_size());
+set_min_heap_size(InitialHeapSize);
 // -Xmx
 } else if (match_option(option, "-Xmx", &tail)) {
 julong long_max_heap_size = 0;
 ArgsRange errcode = parse_memory_size(tail, &long_max_heap_size, 1);
 if (errcode != arg_in_range) {
 jio_fprintf(defaultStream::error_stream(),
 "Invalid maximum heap size: %s\n", option->optionString);
 describe_range_error(errcode);
 return JNI_EINVAL;
 }
-FLAG_SET_CMDLINE(uintx, MaxHeapSize, (size_t) long_max_heap_size);
+FLAG_SET_CMDLINE(uintx, MaxHeapSize, (uintx)long_max_heap_size);
 // Xmaxf
 } else if (match_option(option, "-Xmaxf", &tail)) {
 int maxf = (int)(atof(tail) * 100);
 if (maxf < 0 || maxf > 100) {
 jio_fprintf(defaultStream::error_stream(),
 warning("AggressiveHeap and MaxPermSize values may conflict");
 }
 if (FLAG_IS_DEFAULT(MaxHeapSize)) {
 FLAG_SET_CMDLINE(uintx, MaxHeapSize, initHeapSize);
-set_initial_heap_size(MaxHeapSize);
+FLAG_SET_CMDLINE(uintx, InitialHeapSize, initHeapSize);
 // Currently the minimum size and the initial heap sizes are the same.
-set_min_heap_size(initial_heap_size());
+set_min_heap_size(initHeapSize);
 }
 if (FLAG_IS_DEFAULT(NewSize)) {
 // Make the young generation 3/8ths of the total heap.
 FLAG_SET_CMDLINE(uintx, NewSize,
 ((julong)MaxHeapSize / (julong)8) * (julong)3);
 TraceClassUnloading = true;
 }
 }
 #ifdef SERIALGC
-set_serial_gc_flags();
+force_serial_gc();
 #endif // SERIALGC
 #ifdef KERNEL
 no_shared_spaces();
 #endif // KERNEL
 // Check the GC selections again.
 if (!check_gc_consistency()) {
 return JNI_EINVAL;
 }
-if (UseParallelGC || UseParallelOldGC) {
+if (UseConcMarkSweepGC) {
-// Set some flags for ParallelGC if needed.
+// Set flags for CMS and ParNew.  Check UseConcMarkSweep first
-set_parallel_gc_flags();
+// to ensure that when both UseConcMarkSweepGC and UseParNewGC
-} else if (UseConcMarkSweepGC) {
+// are true, we don't call set_parnew_gc_flags() as well.
-// Set some flags for CMS
 set_cms_and_parnew_gc_flags();
-} else if (UseParNewGC) {
+} else {
-// Set some flags for ParNew
+// Set heap size based on available physical memory
-set_parnew_gc_flags();
+set_heap_size();
-} else if (UseG1GC) {
+// Set per-collector flags
-// Set some flags for garbage-first, if needed.
+if (UseParallelGC || UseParallelOldGC) {
-set_g1_gc_flags();
+set_parallel_gc_flags();
+} else if (UseParNewGC) {
+set_parnew_gc_flags();
+} else if (UseG1GC) {
+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 @ 1064:473cce303f13