jdk-sandbox: comparison hotspot/src/share/vm/runtime/arguments.cpp

equal deleted inserted replaced

-:01571dfab5be
+:92501504191b
 }                                                                 \
 FLAG_SET_DEFAULT(gc, false);                                      \
 }                                                                   \
 } while(0)
-char**  Arguments::_jvm_flags_array             = NULL;
+char** Arguments::_jvm_flags_array              = NULL;
-int     Arguments::_num_jvm_flags               = 0;
+int    Arguments::_num_jvm_flags                = 0;
-char**  Arguments::_jvm_args_array              = NULL;
+char** Arguments::_jvm_args_array               = NULL;
-int     Arguments::_num_jvm_args                = 0;
+int    Arguments::_num_jvm_args                 = 0;
 char*  Arguments::_java_command                 = NULL;
 SystemProperty* Arguments::_system_properties   = NULL;
 const char*  Arguments::_gc_log_filename        = NULL;
 bool   Arguments::_has_profile                  = false;
 size_t Arguments::_conservative_max_heap_alignment = 0;
-uintx  Arguments::_min_heap_size                = 0;
+size_t Arguments::_min_heap_size                = 0;
 uintx  Arguments::_min_heap_free_ratio          = 0;
 uintx  Arguments::_max_heap_free_ratio          = 0;
 Arguments::Mode Arguments::_mode                = _mixed;
 bool   Arguments::_java_compiler                = false;
 bool   Arguments::_xdebug_mode                  = false;
 // Set MaxNewSize to our calculated preferred_max_new_size unless
 // NewSize was set on the command line and it is larger than
 // preferred_max_new_size.
 if (!FLAG_IS_DEFAULT(NewSize)) {   // NewSize explicitly set at command-line
-FLAG_SET_ERGO(uintx, MaxNewSize, MAX2(NewSize, preferred_max_new_size));
+FLAG_SET_ERGO(size_t, MaxNewSize, MAX2(NewSize, preferred_max_new_size));
 } else {
-FLAG_SET_ERGO(uintx, MaxNewSize, preferred_max_new_size);
+FLAG_SET_ERGO(size_t, MaxNewSize, preferred_max_new_size);
 }
 if (PrintGCDetails && Verbose) {
 // Too early to use gclog_or_tty
 tty->print_cr("CMS ergo set MaxNewSize: " SIZE_FORMAT, MaxNewSize);
 }
 }
 if (max_heap > min_new && min_heap_size() > 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(size_t, NewSize, MAX2(NewSize, min_new));
-FLAG_SET_ERGO(uintx, NewSize, MIN2(preferred_max_new_size, NewSize));
+FLAG_SET_ERGO(size_t, NewSize, MIN2(preferred_max_new_size, NewSize));
 if (PrintGCDetails && Verbose) {
 // Too early to use gclog_or_tty
 tty->print_cr("CMS ergo set NewSize: " SIZE_FORMAT, NewSize);
 }
 }
 // Unless explicitly requested otherwise, size old gen
 // so it's NewRatio x of NewSize.
 if (FLAG_IS_DEFAULT(OldSize)) {
 if (max_heap > NewSize) {
-FLAG_SET_ERGO(uintx, OldSize, MIN2(NewRatio*NewSize, max_heap - NewSize));
+FLAG_SET_ERGO(size_t, OldSize, MIN2(NewRatio*NewSize, max_heap - NewSize));
 if (PrintGCDetails && Verbose) {
 // Too early to use gclog_or_tty
 tty->print_cr("CMS ergo set OldSize: " SIZE_FORMAT, OldSize);
 }
 }
 if (FLAG_IS_DEFAULT(OldPLABSize)) {
 if (!FLAG_IS_DEFAULT(ResizeOldPLAB) && !ResizeOldPLAB) {
 // OldPLAB sizing manually turned off: Use a larger default setting,
 // unless it was manually specified. This is because a too-low value
 // will slow down scavenges.
-FLAG_SET_ERGO(uintx, OldPLABSize, CFLS_LAB::_default_static_old_plab_size); // default value before 6631166
+FLAG_SET_ERGO(size_t, OldPLABSize, CFLS_LAB::_default_static_old_plab_size); // default value before 6631166
 } else {
 FLAG_SET_DEFAULT(OldPLABSize, CFLS_LAB::_default_dynamic_old_plab_size); // old CMSParPromoteBlocksToClaim default
 }
 }
 }
 return result;
 }
 // Use static initialization to get the default before parsing
-static const uintx DefaultHeapBaseMinAddress = HeapBaseMinAddress;
+static const size_t DefaultHeapBaseMinAddress = HeapBaseMinAddress;
 void Arguments::set_heap_size() {
 if (!FLAG_IS_DEFAULT(DefaultMaxRAMFraction)) {
 // Deprecated flag
 FLAG_SET_CMDLINE(uintx, MaxRAMFraction, DefaultMaxRAMFraction);
 if (!FLAG_IS_DEFAULT(HeapBaseMinAddress)) {
 if (HeapBaseMinAddress < DefaultHeapBaseMinAddress) {
 // matches compressed oops printing flags
 if (PrintCompressedOopsMode || (PrintMiscellaneous && Verbose)) {
 jio_fprintf(defaultStream::error_stream(),
-"HeapBaseMinAddress must be at least " UINTX_FORMAT
+"HeapBaseMinAddress must be at least " SIZE_FORMAT
-" (" UINTX_FORMAT "G) which is greater than value given "
+" (" SIZE_FORMAT "G) which is greater than value given "
-UINTX_FORMAT "\n",
+SIZE_FORMAT "\n",
 DefaultHeapBaseMinAddress,
 DefaultHeapBaseMinAddress/G,
 HeapBaseMinAddress);
 }
-FLAG_SET_ERGO(uintx, HeapBaseMinAddress, DefaultHeapBaseMinAddress);
+FLAG_SET_ERGO(size_t, HeapBaseMinAddress, DefaultHeapBaseMinAddress);
 }
 }
 if (HeapBaseMinAddress + MaxHeapSize < max_coop_heap) {
 // Heap should be above HeapBaseMinAddress to get zero based compressed oops
 if (PrintGCDetails && Verbose) {
 // Cannot use gclog_or_tty yet.
 tty->print_cr("  Maximum heap size " SIZE_FORMAT, (size_t) reasonable_max);
 }
-FLAG_SET_ERGO(uintx, MaxHeapSize, (uintx)reasonable_max);
+FLAG_SET_ERGO(size_t, MaxHeapSize, (size_t)reasonable_max);
 }
 // If the minimum or initial heap_size have not been set or requested to be set
 // ergonomically, set them accordingly.
 if (InitialHeapSize == 0 || min_heap_size() == 0) {
 reasonable_initial = limit_by_allocatable_memory(reasonable_initial);
 if (PrintGCDetails && Verbose) {
 // Cannot use gclog_or_tty yet.
-tty->print_cr("  Initial heap size " SIZE_FORMAT, (uintx)reasonable_initial);
+tty->print_cr("  Initial heap size " SIZE_FORMAT, (size_t)reasonable_initial);
 }
-FLAG_SET_ERGO(uintx, InitialHeapSize, (uintx)reasonable_initial);
+FLAG_SET_ERGO(size_t, InitialHeapSize, (size_t)reasonable_initial);
 }
 // If the minimum heap size has not been set (via -Xms),
 // synchronize with InitialHeapSize to avoid errors with the default value.
 if (min_heap_size() == 0) {
-set_min_heap_size(MIN2((uintx)reasonable_minimum, InitialHeapSize));
+set_min_heap_size(MIN2((size_t)reasonable_minimum, InitialHeapSize));
 if (PrintGCDetails && Verbose) {
 // Cannot use gclog_or_tty yet.
 tty->print_cr("  Minimum heap size " SIZE_FORMAT, min_heap_size());
 }
 }
 UseGCLogFileRotation = false;
 }
 }
 if (UseGCLogFileRotation && (GCLogFileSize != 0) && (GCLogFileSize < 8*K)) {
-FLAG_SET_CMDLINE(uintx, GCLogFileSize, 8*K);
+FLAG_SET_CMDLINE(size_t, GCLogFileSize, 8*K);
 jio_fprintf(defaultStream::output_stream(),
 "GCLogFileSize changed to minimum 8K\n");
 }
 }
 1, (max_jint - 1), "MarkStackSizeMax");
 status = status && verify_interval(NUMAChunkResizeWeight, 0, 100, "NUMAChunkResizeWeight");
 status = status && verify_min_value(LogEventsBufferEntries, 1, "LogEventsBufferEntries");
-status = status && verify_min_value(HeapSizePerGCThread, (uintx) os::vm_page_size(), "HeapSizePerGCThread");
+status = status && verify_min_value(HeapSizePerGCThread, (size_t) os::vm_page_size(), "HeapSizePerGCThread");
 status = status && verify_min_value(GCTaskTimeStampEntries, 1, "GCTaskTimeStampEntries");
 status = status && verify_percentage(ParallelGCBufferWastePct, "ParallelGCBufferWastePct");
 status = status && verify_interval(TargetPLABWastePct, 1, 100, "TargetPLABWastePct");
 jio_fprintf(defaultStream::error_stream(),
 "Invalid initial young generation size: %s\n", option->optionString);
 describe_range_error(errcode);
 return JNI_EINVAL;
 }
-FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_young_size);
+FLAG_SET_CMDLINE(size_t, MaxNewSize, (size_t)long_initial_young_size);
-FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_young_size);
+FLAG_SET_CMDLINE(size_t, NewSize, (size_t)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);
+set_min_heap_size((size_t)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);
+FLAG_SET_CMDLINE(size_t, InitialHeapSize, (size_t)long_initial_heap_size);
 // -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) {
 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, (uintx)long_max_heap_size);
+FLAG_SET_CMDLINE(size_t, MaxHeapSize, (size_t)long_max_heap_size);
 // Xmaxf
 } else if (match_option(option, "-Xmaxf", &tail)) {
 char* err;
 int maxf = (int)(strtod(tail, &err) * 100);
 if (*err != '\0' || *tail == '\0' || maxf < 0 || maxf > 100) {
 } else if (match_option(option, "-Xconcurrentio")) {
 FLAG_SET_CMDLINE(bool, UseLWPSynchronization, true);
 FLAG_SET_CMDLINE(bool, BackgroundCompilation, false);
 FLAG_SET_CMDLINE(intx, DeferThrSuspendLoopCount, 1);
 FLAG_SET_CMDLINE(bool, UseTLAB, false);
-FLAG_SET_CMDLINE(uintx, NewSizeThreadIncrease, 16 * K);  // 20Kb per thread added to new generation
+FLAG_SET_CMDLINE(size_t, NewSizeThreadIncrease, 16 * K);  // 20Kb per thread added to new generation
 // -Xinternalversion
 } else if (match_option(option, "-Xinternalversion")) {
 jio_fprintf(defaultStream::output_stream(), "%s\n",
 VM_Version::internal_vm_info_string());
 total_memory - (julong)160*M);
 initHeapSize = limit_by_allocatable_memory(initHeapSize);
 if (FLAG_IS_DEFAULT(MaxHeapSize)) {
-FLAG_SET_CMDLINE(uintx, MaxHeapSize, initHeapSize);
+FLAG_SET_CMDLINE(size_t, MaxHeapSize, initHeapSize);
-FLAG_SET_CMDLINE(uintx, InitialHeapSize, initHeapSize);
+FLAG_SET_CMDLINE(size_t, InitialHeapSize, initHeapSize);
 // Currently the minimum size and the initial heap sizes are the same.
 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,
+FLAG_SET_CMDLINE(size_t, NewSize,
 ((julong)MaxHeapSize / (julong)8) * (julong)3);
-FLAG_SET_CMDLINE(uintx, MaxNewSize, NewSize);
+FLAG_SET_CMDLINE(size_t, MaxNewSize, NewSize);
 }
 #ifndef _ALLBSD_SOURCE  // UseLargePages is not yet supported on BSD.
 FLAG_SET_DEFAULT(UseLargePages, true);
 #endif
 // Increase some data structure sizes for efficiency
-FLAG_SET_CMDLINE(uintx, BaseFootPrintEstimate, MaxHeapSize);
+FLAG_SET_CMDLINE(size_t, BaseFootPrintEstimate, MaxHeapSize);
 FLAG_SET_CMDLINE(bool, ResizeTLAB, false);
-FLAG_SET_CMDLINE(uintx, TLABSize, 256*K);
+FLAG_SET_CMDLINE(size_t, TLABSize, 256*K);
 // See the OldPLABSize comment below, but replace 'after promotion'
 // with 'after copying'.  YoungPLABSize is the size of the survivor
 // space per-gc-thread buffers.  The default is 4kw.
-FLAG_SET_CMDLINE(uintx, YoungPLABSize, 256*K);      // Note: this is in words
+FLAG_SET_CMDLINE(size_t, YoungPLABSize, 256*K);      // Note: this is in words
 // OldPLABSize is the size of the buffers in the old gen that
 // UseParallelGC uses to promote live data that doesn't fit in the
 // survivor spaces.  At any given time, there's one for each gc thread.
 // The default size is 1kw. These buffers are rarely used, since the
 // is that a bigger PLAB results in retaining something like the
 // original allocation order after promotion, which improves mutator
 // locality.  A minor effect may be that larger PLABs reduce the
 // number of PLAB allocation events during gc.  The value of 8kw
 // was arrived at by experimenting with specjbb.
-FLAG_SET_CMDLINE(uintx, OldPLABSize, 8*K);  // Note: this is in words
+FLAG_SET_CMDLINE(size_t, OldPLABSize, 8*K);  // Note: this is in words
 // Enable parallel GC and adaptive generation sizing
 FLAG_SET_CMDLINE(bool, UseParallelGC, true);
 FLAG_SET_DEFAULT(ParallelGCThreads,
 Abstract_VM_Version::parallel_worker_threads());
 return JNI_EINVAL;
 }
 jio_fprintf(defaultStream::error_stream(),
 "Please use -XX:MarkStackSize in place of "
 "-XX:CMSMarkStackSize or -XX:G1MarkStackSize in the future\n");
-FLAG_SET_CMDLINE(uintx, MarkStackSize, stack_size);
+FLAG_SET_CMDLINE(size_t, MarkStackSize, stack_size);
 } else if (match_option(option, "-XX:CMSMarkStackSizeMax=", &tail)) {
 julong max_stack_size = 0;
 ArgsRange errcode = parse_memory_size(tail, &max_stack_size, 1);
 if (errcode != arg_in_range) {
 jio_fprintf(defaultStream::error_stream(),
 return JNI_EINVAL;
 }
 jio_fprintf(defaultStream::error_stream(),
 "Please use -XX:MarkStackSizeMax in place of "
 "-XX:CMSMarkStackSizeMax in the future\n");
-FLAG_SET_CMDLINE(uintx, MarkStackSizeMax, max_stack_size);
+FLAG_SET_CMDLINE(size_t, MarkStackSizeMax, max_stack_size);
 } else if (match_option(option, "-XX:ParallelMarkingThreads=", &tail) ||
 match_option(option, "-XX:ParallelCMSThreads=", &tail)) {
 uintx conc_threads = 0;
 if (!parse_uintx(tail, &conc_threads, 1)) {
 jio_fprintf(defaultStream::error_stream(),
 "Invalid maximum direct memory size: %s\n",
 option->optionString);
 describe_range_error(errcode);
 return JNI_EINVAL;
 }
-FLAG_SET_CMDLINE(uintx, MaxDirectMemorySize, max_direct_memory_size);
+FLAG_SET_CMDLINE(size_t, MaxDirectMemorySize, max_direct_memory_size);
 #if !INCLUDE_MANAGEMENT
 } else if (match_option(option, "-XX:+ManagementServer")) {
 jio_fprintf(defaultStream::error_stream(),
 "ManagementServer is not supported in this VM.\n");
 return JNI_ERR;

changeset 29697	92501504191b
parent 29696	01571dfab5be
child 30120	af79e35d33e1
child 30201	cfe623bb3f9c
child 29870	ea8305ce32fa