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

comparison src/share/vm/runtime/arguments.cpp @ 13102:f9f4503a4ab5

Merge

author	Christos Kotselidis <christos.kotselidis@oracle.com>
date	Thu, 21 Nov 2013 15:04:54 +0100
parents	096c224171c4
children	fbcdae53b17e

comparison

equal deleted inserted replaced

-:790ebab62d23
+:f9f4503a4ab5
 }
 if (!UseInterpreter) { // -Xcomp
 Tier3InvokeNotifyFreqLog = 0;
 Tier4InvocationThreshold = 0;
 }
-if (FLAG_IS_DEFAULT(NmethodSweepFraction)) {
-FLAG_SET_DEFAULT(NmethodSweepFraction, 1 + ReservedCodeCacheSize / (16 * M));
-}
 }
 #if INCLUDE_ALL_GCS
 static void disable_adaptive_size_policy(const char* collector_name) {
 if (UseAdaptiveSizePolicy) {
 // We need to fit both the NULL page and the heap into the memory budget, while
 // keeping alignment constraints of the heap. To guarantee the latter, as the
 // NULL page is located before the heap, we pad the NULL page to the conservative
 // maximum alignment that the GC may ever impose upon the heap.
 size_t displacement_due_to_null_page = align_size_up_(os::vm_page_size(),
-Arguments::conservative_max_heap_alignment());
+_conservative_max_heap_alignment);
 LP64_ONLY(return OopEncodingHeapMax - displacement_due_to_null_page);
 NOT_LP64(ShouldNotReachHere(); return 0);
 }
 } else if (UseG1GC) {
 heap_alignment = G1CollectedHeap::conservative_max_heap_alignment();
 }
 #endif // INCLUDE_ALL_GCS
 _conservative_max_heap_alignment = MAX3(heap_alignment, os::max_page_size(),
-CollectorPolicy::compute_max_alignment());
+CollectorPolicy::compute_heap_alignment());
 }
 void Arguments::set_ergonomics_flags() {
 if (os::is_server_class_machine()) {
 jio_fprintf(defaultStream::error_stream(),
 "Conflicting collector combinations in option list; "
 "please refer to the release notes for the combinations "
 "allowed\n");
 status = false;
-} else if (ReservedCodeCacheSize > 2*G) {
-// Code cache size larger than MAXINT is not supported.
-jio_fprintf(defaultStream::error_stream(),
-"Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M,
-(2*G)/M);
-status = false;
 }
 return status;
 }
 void Arguments::check_deprecated_gcs() {
 "and will likely be removed in future release");
 }
 if (FLAG_IS_CMDLINE(DefaultMaxRAMFraction)) {
 warning("DefaultMaxRAMFraction is deprecated and will likely be removed in a future release. "
 "Use MaxRAMFraction instead.");
+}
+if (FLAG_IS_CMDLINE(UseCMSCompactAtFullCollection)) {
+warning("UseCMSCompactAtFullCollection is deprecated and will likely be removed in a future release.");
+}
+if (FLAG_IS_CMDLINE(CMSFullGCsBeforeCompaction)) {
+warning("CMSFullGCsBeforeCompaction is deprecated and will likely be removed in a future release.");
+}
+if (FLAG_IS_CMDLINE(UseCMSCollectionPassing)) {
+warning("UseCMSCollectionPassing is deprecated and will likely be removed in a future release.");
 }
 }
 // Check stack pages settings
 bool Arguments::check_stack_pages()
 // Divide by bucket size to prevent a large size from causing rollover when
 // calculating amount of memory needed to be allocated for the String table.
 status = status && verify_interval(StringTableSize, minimumStringTableSize,
 (max_uintx / StringTable::bucket_size()), "StringTable size");
+status = status && verify_interval(SymbolTableSize, minimumSymbolTableSize,
+(max_uintx / SymbolTable::bucket_size()), "SymbolTable size");
 if (MinHeapFreeRatio > MaxHeapFreeRatio) {
 jio_fprintf(defaultStream::error_stream(),
 "MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
 "equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n",
 status = status && verify_min_value(ParGCArrayScanChunk, 1, "ParGCArrayScanChunk");
 #if INCLUDE_ALL_GCS
 if (UseG1GC) {
+status = status && verify_percentage(G1NewSizePercent, "G1NewSizePercent");
+status = status && verify_percentage(G1MaxNewSizePercent, "G1MaxNewSizePercent");
+status = status && verify_interval(G1NewSizePercent, 0, G1MaxNewSizePercent, "G1NewSizePercent");
 status = status && verify_percentage(InitiatingHeapOccupancyPercent,
 "InitiatingHeapOccupancyPercent");
 status = status && verify_min_value(G1RefProcDrainInterval, 1,
 "G1RefProcDrainInterval");
 status = status && verify_min_value((intx)G1ConcMarkStepDurationMillis, 1,
 // -Xbatch
 } else if (match_option(option, "-Xbatch", &tail)) {
 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false);
 // -Xmn for compatibility with other JVM vendors
 } else if (match_option(option, "-Xmn", &tail)) {
-julong long_initial_eden_size = 0;
+julong long_initial_young_size = 0;
-ArgsRange errcode = parse_memory_size(tail, &long_initial_eden_size, 1);
+ArgsRange errcode = parse_memory_size(tail, &long_initial_young_size, 1);
 if (errcode != arg_in_range) {
 jio_fprintf(defaultStream::error_stream(),
-"Invalid initial eden size: %s\n", option->optionString);
+"Invalid initial young generation size: %s\n", option->optionString);
 describe_range_error(errcode);
 return JNI_EINVAL;
 }
-FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_eden_size);
+FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_young_size);
-FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_eden_size);
+FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_young_size);
 // -Xms
 } else if (match_option(option, "-Xms", &tail)) {
 julong long_initial_heap_size = 0;
 // an initial heap size of 0 means automatically determine
 ArgsRange errcode = parse_memory_size(tail, &long_initial_heap_size, 0);
 jio_fprintf(defaultStream::error_stream(),
 "Invalid initial heap size: %s\n", option->optionString);
 describe_range_error(errcode);
 return JNI_EINVAL;
 }
+set_min_heap_size((uintx)long_initial_heap_size);
+// Currently the minimum size and the initial heap sizes are the same.
+// Can be overridden with -XX:InitialHeapSize.
 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(InitialHeapSize);
 // -Xmx
 } else if (match_option(option, "-Xmx", &tail) || match_option(option, "-XX:MaxHeapSize=", &tail)) {
 julong long_max_heap_size = 0;
 ArgsRange errcode = parse_memory_size(tail, &long_max_heap_size, 1);
 if (errcode != arg_in_range) {
 return JNI_EINVAL;
 }
 FLAG_SET_CMDLINE(uintx, MaxHeapSize, (uintx)long_max_heap_size);
 // Xmaxf
 } else if (match_option(option, "-Xmaxf", &tail)) {
-int maxf = (int)(atof(tail) * 100);
+char* err;
-if (maxf < 0 || maxf > 100) {
+int maxf = (int)(strtod(tail, &err) * 100);
+if (*err != '\0' || maxf < 0 || maxf > 100) {
 jio_fprintf(defaultStream::error_stream(),
 "Bad max heap free percentage size: %s\n",
 option->optionString);
 return JNI_EINVAL;
 } else {
 FLAG_SET_CMDLINE(uintx, MaxHeapFreeRatio, maxf);
 }
 // Xminf
 } else if (match_option(option, "-Xminf", &tail)) {
-int minf = (int)(atof(tail) * 100);
+char* err;
-if (minf < 0 || minf > 100) {
+int minf = (int)(strtod(tail, &err) * 100);
+if (*err != '\0' || minf < 0 || minf > 100) {
 jio_fprintf(defaultStream::error_stream(),
 "Bad min heap free percentage size: %s\n",
 option->optionString);
 return JNI_EINVAL;
 } else {
 if (CompilationPolicyChoice >= 2) {
 vm_exit_during_initialization(
 "Incompatible compilation policy selected", NULL);
 }
 }
+// Set NmethodSweepFraction after the size of the code cache is adapted (in case of tiered)
+if (FLAG_IS_DEFAULT(NmethodSweepFraction)) {
+FLAG_SET_DEFAULT(NmethodSweepFraction, 1 + ReservedCodeCacheSize / (16 * M));
+}
 // Set heap size based on available physical memory
 set_heap_size();
 #if INCLUDE_ALL_GCS
 }
 }
 #else // INCLUDE_ALL_GCS
 assert(verify_serial_gc_flags(), "SerialGC unset");
 #endif // INCLUDE_ALL_GCS
+// Initialize Metaspace flags and alignments.
+Metaspace::ergo_initialize();
 // Set bytecode rewriting flags
 set_bytecode_flags();
 // Set flags if Aggressive optimization flags (-XX:+AggressiveOpts) enabled.
 #endif
 if (IncrementalInline && FLAG_IS_DEFAULT(MaxNodeLimit)) {
 // incremental inlining: bump MaxNodeLimit
 FLAG_SET_DEFAULT(MaxNodeLimit, (intx)75000);
 }
+if (!UseTypeSpeculation && FLAG_IS_DEFAULT(TypeProfileLevel)) {
+// nothing to use the profiling, turn if off
+FLAG_SET_DEFAULT(TypeProfileLevel, 0);
+}
+if (UseTypeSpeculation && FLAG_IS_DEFAULT(ReplaceInParentMaps)) {
+// Doing the replace in parent maps helps speculation
+FLAG_SET_DEFAULT(ReplaceInParentMaps, true);
+}
+#ifndef X86
+// Only on x86 for now
+FLAG_SET_DEFAULT(TypeProfileLevel, 0);
+#endif
 #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 @ 13102:f9f4503a4ab5