--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/gc/cms/cmsArguments.cpp Tue Nov 07 11:58:52 2017 +0100
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2017, Red Hat, Inc. and/or its affiliates.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc/cms/cmsArguments.hpp"
+#include "gc/cms/compactibleFreeListSpace.hpp"
+#include "gc/shared/genCollectedHeap.hpp"
+#include "runtime/arguments.hpp"
+#include "runtime/globals.hpp"
+#include "runtime/globals_extension.hpp"
+#include "runtime/vm_version.hpp"
+#include "utilities/defaultStream.hpp"
+
+size_t CMSArguments::conservative_max_heap_alignment() {
+ return GenCollectedHeap::conservative_max_heap_alignment();
+}
+
+void CMSArguments::set_parnew_gc_flags() {
+ assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC && !UseG1GC,
+ "control point invariant");
+ assert(UseConcMarkSweepGC, "CMS is expected to be on here");
+
+ if (FLAG_IS_DEFAULT(ParallelGCThreads)) {
+ FLAG_SET_DEFAULT(ParallelGCThreads, Abstract_VM_Version::parallel_worker_threads());
+ assert(ParallelGCThreads > 0, "We should always have at least one thread by default");
+ } else if (ParallelGCThreads == 0) {
+ jio_fprintf(defaultStream::error_stream(),
+ "The ParNew GC can not be combined with -XX:ParallelGCThreads=0\n");
+ vm_exit(1);
+ }
+
+ // 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.
+ // See CR 6362902.
+ if (FLAG_IS_DEFAULT(YoungPLABSize)) {
+ FLAG_SET_DEFAULT(YoungPLABSize, (intx)1024);
+ }
+ if (FLAG_IS_DEFAULT(OldPLABSize)) {
+ FLAG_SET_DEFAULT(OldPLABSize, (intx)1024);
+ }
+
+ // When using compressed oops, we use local overflow stacks,
+ // rather than using a global overflow list chained through
+ // the klass word of the object's pre-image.
+ if (UseCompressedOops && !ParGCUseLocalOverflow) {
+ if (!FLAG_IS_DEFAULT(ParGCUseLocalOverflow)) {
+ warning("Forcing +ParGCUseLocalOverflow: needed if using compressed references");
+ }
+ FLAG_SET_DEFAULT(ParGCUseLocalOverflow, true);
+ }
+ assert(ParGCUseLocalOverflow || !UseCompressedOops, "Error");
+}
+
+// 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 CMSArguments::initialize_flags() {
+ GCArguments::initialize_flags();
+ assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC, "Error");
+ assert(UseConcMarkSweepGC, "CMS is expected to be on here");
+
+ // Set CMS global values
+ CompactibleFreeListSpace::set_cms_values();
+
+ // Turn off AdaptiveSizePolicy by default for cms until it is complete.
+ disable_adaptive_size_policy("UseConcMarkSweepGC");
+
+ set_parnew_gc_flags();
+
+ size_t max_heap = align_down(MaxHeapSize,
+ CardTableRS::ct_max_alignment_constraint());
+
+ // Now make adjustments for CMS
+ intx tenuring_default = (intx)6;
+ size_t young_gen_per_worker = CMSYoungGenPerWorker;
+
+ // Preferred young gen size for "short" pauses:
+ // upper bound depends on # of threads and NewRatio.
+ const size_t preferred_max_new_size_unaligned =
+ MIN2(max_heap/(NewRatio+1), ScaleForWordSize(young_gen_per_worker * ParallelGCThreads));
+ size_t preferred_max_new_size =
+ align_up(preferred_max_new_size_unaligned, os::vm_page_size());
+
+ // Unless explicitly requested otherwise, size young gen
+ // for "short" pauses ~ CMSYoungGenPerWorker*ParallelGCThreads
+
+ // If either MaxNewSize or NewRatio is set on the command line,
+ // assume the user is trying to set the size of the young gen.
+ if (FLAG_IS_DEFAULT(MaxNewSize) && FLAG_IS_DEFAULT(NewRatio)) {
+
+ // 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(size_t, MaxNewSize, MAX2(NewSize, preferred_max_new_size));
+ } else {
+ FLAG_SET_ERGO(size_t, MaxNewSize, preferred_max_new_size);
+ }
+ log_trace(gc, heap)("CMS ergo set MaxNewSize: " SIZE_FORMAT, MaxNewSize);
+
+ // Code along this path potentially sets NewSize and OldSize
+ log_trace(gc, heap)("CMS set min_heap_size: " SIZE_FORMAT " initial_heap_size: " SIZE_FORMAT " max_heap: " SIZE_FORMAT,
+ Arguments::min_heap_size(), InitialHeapSize, max_heap);
+ size_t min_new = preferred_max_new_size;
+ if (FLAG_IS_CMDLINE(NewSize)) {
+ min_new = NewSize;
+ }
+ if (max_heap > min_new && Arguments::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(size_t, NewSize, MAX2(NewSize, min_new));
+ FLAG_SET_ERGO(size_t, NewSize, MIN2(preferred_max_new_size, NewSize));
+ log_trace(gc, heap)("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(size_t, OldSize, MIN2(NewRatio*NewSize, max_heap - NewSize));
+ log_trace(gc, heap)("CMS ergo set OldSize: " SIZE_FORMAT, OldSize);
+ }
+ }
+ }
+ }
+ // Unless explicitly requested otherwise, definitely
+ // promote all objects surviving "tenuring_default" scavenges.
+ if (FLAG_IS_DEFAULT(MaxTenuringThreshold) &&
+ FLAG_IS_DEFAULT(SurvivorRatio)) {
+ FLAG_SET_ERGO(uintx, MaxTenuringThreshold, tenuring_default);
+ }
+ // If we decided above (or user explicitly requested)
+ // `promote all' (via MaxTenuringThreshold := 0),
+ // prefer minuscule survivor spaces so as not to waste
+ // space for (non-existent) survivors
+ if (FLAG_IS_DEFAULT(SurvivorRatio) && MaxTenuringThreshold == 0) {
+ FLAG_SET_ERGO(uintx, SurvivorRatio, MAX2((uintx)1024, SurvivorRatio));
+ }
+
+ // OldPLABSize is interpreted in CMS as not the size of the PLAB in words,
+ // but rather the number of free blocks of a given size that are used when
+ // replenishing the local per-worker free list caches.
+ 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(size_t, OldPLABSize, CompactibleFreeListSpaceLAB::_default_static_old_plab_size); // default value before 6631166
+ } else {
+ FLAG_SET_DEFAULT(OldPLABSize, CompactibleFreeListSpaceLAB::_default_dynamic_old_plab_size); // old CMSParPromoteBlocksToClaim default
+ }
+ }
+
+ // If either of the static initialization defaults have changed, note this
+ // modification.
+ if (!FLAG_IS_DEFAULT(OldPLABSize) || !FLAG_IS_DEFAULT(OldPLABWeight)) {
+ CompactibleFreeListSpaceLAB::modify_initialization(OldPLABSize, OldPLABWeight);
+ }
+
+ log_trace(gc)("MarkStackSize: %uk MarkStackSizeMax: %uk", (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K));
+}
+
+void CMSArguments::disable_adaptive_size_policy(const char* collector_name) {
+ if (UseAdaptiveSizePolicy) {
+ if (FLAG_IS_CMDLINE(UseAdaptiveSizePolicy)) {
+ warning("Disabling UseAdaptiveSizePolicy; it is incompatible with %s.",
+ collector_name);
+ }
+ FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false);
+ }
+}