1 /*
   2  * Copyright (c) 2017, Red Hat, Inc. and/or its affiliates.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "gc/cms/cmsArguments.hpp"
  27 #include "gc/cms/cmsCollectorPolicy.hpp"
  28 #include "gc/cms/cmsHeap.hpp"
  29 #include "gc/cms/compactibleFreeListSpace.hpp"
  30 #include "gc/shared/gcArguments.inline.hpp"
  31 #include "gc/shared/genCollectedHeap.hpp"
  32 #include "runtime/arguments.hpp"
  33 #include "runtime/globals.hpp"
  34 #include "runtime/globals_extension.hpp"
  35 #include "runtime/vm_version.hpp"
  36 #include "utilities/defaultStream.hpp"
  37 
  38 size_t CMSArguments::conservative_max_heap_alignment() {
  39   return GenCollectedHeap::conservative_max_heap_alignment();
  40 }
  41 
  42 void CMSArguments::set_parnew_gc_flags() {
  43   assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC && !UseG1GC,
  44          "control point invariant");
  45   assert(UseConcMarkSweepGC, "CMS is expected to be on here");
  46 
  47   if (FLAG_IS_DEFAULT(ParallelGCThreads)) {
  48     FLAG_SET_DEFAULT(ParallelGCThreads, Abstract_VM_Version::parallel_worker_threads());
  49     assert(ParallelGCThreads > 0, "We should always have at least one thread by default");
  50   } else if (ParallelGCThreads == 0) {
  51     jio_fprintf(defaultStream::error_stream(),
  52         "The ParNew GC can not be combined with -XX:ParallelGCThreads=0\n");
  53     vm_exit(1);
  54   }
  55 
  56   // By default YoungPLABSize and OldPLABSize are set to 4096 and 1024 respectively,
  57   // these settings are default for Parallel Scavenger. For ParNew+Tenured configuration
  58   // we set them to 1024 and 1024.
  59   // See CR 6362902.
  60   if (FLAG_IS_DEFAULT(YoungPLABSize)) {
  61     FLAG_SET_DEFAULT(YoungPLABSize, (intx)1024);
  62   }
  63   if (FLAG_IS_DEFAULT(OldPLABSize)) {
  64     FLAG_SET_DEFAULT(OldPLABSize, (intx)1024);
  65   }
  66 
  67   // When using compressed oops, we use local overflow stacks,
  68   // rather than using a global overflow list chained through
  69   // the klass word of the object's pre-image.
  70   if (UseCompressedOops && !ParGCUseLocalOverflow) {
  71     if (!FLAG_IS_DEFAULT(ParGCUseLocalOverflow)) {
  72       warning("Forcing +ParGCUseLocalOverflow: needed if using compressed references");
  73     }
  74     FLAG_SET_DEFAULT(ParGCUseLocalOverflow, true);
  75   }
  76   assert(ParGCUseLocalOverflow || !UseCompressedOops, "Error");
  77 }
  78 
  79 // Adjust some sizes to suit CMS and/or ParNew needs; these work well on
  80 // sparc/solaris for certain applications, but would gain from
  81 // further optimization and tuning efforts, and would almost
  82 // certainly gain from analysis of platform and environment.
  83 void CMSArguments::initialize() {
  84   GCArguments::initialize();
  85   assert(!UseSerialGC && !UseParallelOldGC && !UseParallelGC, "Error");
  86   assert(UseConcMarkSweepGC, "CMS is expected to be on here");
  87 
  88   // Set CMS global values
  89   CompactibleFreeListSpace::set_cms_values();
  90 
  91   // Turn off AdaptiveSizePolicy by default for cms until it is complete.
  92   disable_adaptive_size_policy("UseConcMarkSweepGC");
  93 
  94   set_parnew_gc_flags();
  95 
  96   size_t max_heap = align_down(MaxHeapSize,
  97                                CardTableRS::ct_max_alignment_constraint());
  98 
  99   // Now make adjustments for CMS
 100   intx   tenuring_default = (intx)6;
 101   size_t young_gen_per_worker = CMSYoungGenPerWorker;
 102 
 103   // Preferred young gen size for "short" pauses:
 104   // upper bound depends on # of threads and NewRatio.
 105   const size_t preferred_max_new_size_unaligned =
 106     MIN2(max_heap/(NewRatio+1), ScaleForWordSize(young_gen_per_worker * ParallelGCThreads));
 107   size_t preferred_max_new_size =
 108     align_up(preferred_max_new_size_unaligned, os::vm_page_size());
 109 
 110   // Unless explicitly requested otherwise, size young gen
 111   // for "short" pauses ~ CMSYoungGenPerWorker*ParallelGCThreads
 112 
 113   // If either MaxNewSize or NewRatio is set on the command line,
 114   // assume the user is trying to set the size of the young gen.
 115   if (FLAG_IS_DEFAULT(MaxNewSize) && FLAG_IS_DEFAULT(NewRatio)) {
 116 
 117     // Set MaxNewSize to our calculated preferred_max_new_size unless
 118     // NewSize was set on the command line and it is larger than
 119     // preferred_max_new_size.
 120     if (!FLAG_IS_DEFAULT(NewSize)) {   // NewSize explicitly set at command-line
 121       FLAG_SET_ERGO(size_t, MaxNewSize, MAX2(NewSize, preferred_max_new_size));
 122     } else {
 123       FLAG_SET_ERGO(size_t, MaxNewSize, preferred_max_new_size);
 124     }
 125     log_trace(gc, heap)("CMS ergo set MaxNewSize: " SIZE_FORMAT, MaxNewSize);
 126 
 127     // Code along this path potentially sets NewSize and OldSize
 128     log_trace(gc, heap)("CMS set min_heap_size: " SIZE_FORMAT " initial_heap_size:  " SIZE_FORMAT " max_heap: " SIZE_FORMAT,
 129                         Arguments::min_heap_size(), InitialHeapSize, max_heap);
 130     size_t min_new = preferred_max_new_size;
 131     if (FLAG_IS_CMDLINE(NewSize)) {
 132       min_new = NewSize;
 133     }
 134     if (max_heap > min_new && Arguments::min_heap_size() > min_new) {
 135       // Unless explicitly requested otherwise, make young gen
 136       // at least min_new, and at most preferred_max_new_size.
 137       if (FLAG_IS_DEFAULT(NewSize)) {
 138         FLAG_SET_ERGO(size_t, NewSize, MAX2(NewSize, min_new));
 139         FLAG_SET_ERGO(size_t, NewSize, MIN2(preferred_max_new_size, NewSize));
 140         log_trace(gc, heap)("CMS ergo set NewSize: " SIZE_FORMAT, NewSize);
 141       }
 142       // Unless explicitly requested otherwise, size old gen
 143       // so it's NewRatio x of NewSize.
 144       if (FLAG_IS_DEFAULT(OldSize)) {
 145         if (max_heap > NewSize) {
 146           FLAG_SET_ERGO(size_t, OldSize, MIN2(NewRatio*NewSize, max_heap - NewSize));
 147           log_trace(gc, heap)("CMS ergo set OldSize: " SIZE_FORMAT, OldSize);
 148         }
 149       }
 150     }
 151   }
 152   // Unless explicitly requested otherwise, definitely
 153   // promote all objects surviving "tenuring_default" scavenges.
 154   if (FLAG_IS_DEFAULT(MaxTenuringThreshold) &&
 155       FLAG_IS_DEFAULT(SurvivorRatio)) {
 156     FLAG_SET_ERGO(uintx, MaxTenuringThreshold, tenuring_default);
 157   }
 158   // If we decided above (or user explicitly requested)
 159   // `promote all' (via MaxTenuringThreshold := 0),
 160   // prefer minuscule survivor spaces so as not to waste
 161   // space for (non-existent) survivors
 162   if (FLAG_IS_DEFAULT(SurvivorRatio) && MaxTenuringThreshold == 0) {
 163     FLAG_SET_ERGO(uintx, SurvivorRatio, MAX2((uintx)1024, SurvivorRatio));
 164   }
 165 
 166   // OldPLABSize is interpreted in CMS as not the size of the PLAB in words,
 167   // but rather the number of free blocks of a given size that are used when
 168   // replenishing the local per-worker free list caches.
 169   if (FLAG_IS_DEFAULT(OldPLABSize)) {
 170     if (!FLAG_IS_DEFAULT(ResizeOldPLAB) && !ResizeOldPLAB) {
 171       // OldPLAB sizing manually turned off: Use a larger default setting,
 172       // unless it was manually specified. This is because a too-low value
 173       // will slow down scavenges.
 174       FLAG_SET_ERGO(size_t, OldPLABSize, CompactibleFreeListSpaceLAB::_default_static_old_plab_size); // default value before 6631166
 175     } else {
 176       FLAG_SET_DEFAULT(OldPLABSize, CompactibleFreeListSpaceLAB::_default_dynamic_old_plab_size); // old CMSParPromoteBlocksToClaim default
 177     }
 178   }
 179 
 180   // If either of the static initialization defaults have changed, note this
 181   // modification.
 182   if (!FLAG_IS_DEFAULT(OldPLABSize) || !FLAG_IS_DEFAULT(OldPLABWeight)) {
 183     CompactibleFreeListSpaceLAB::modify_initialization(OldPLABSize, OldPLABWeight);
 184   }
 185 
 186   log_trace(gc)("MarkStackSize: %uk  MarkStackSizeMax: %uk", (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K));
 187 }
 188 
 189 void CMSArguments::disable_adaptive_size_policy(const char* collector_name) {
 190   if (UseAdaptiveSizePolicy) {
 191     if (FLAG_IS_CMDLINE(UseAdaptiveSizePolicy)) {
 192       warning("Disabling UseAdaptiveSizePolicy; it is incompatible with %s.",
 193               collector_name);
 194     }
 195     FLAG_SET_DEFAULT(UseAdaptiveSizePolicy, false);
 196   }
 197 }
 198 
 199 CollectedHeap* CMSArguments::create_heap() {
 200   return create_heap_with_policy<CMSHeap, ConcurrentMarkSweepPolicy>();
 201 }