31 #include "memory/gcLocker.inline.hpp" 32 #include "memory/genCollectedHeap.hpp" 33 #include "memory/generationSpec.hpp" 34 #include "memory/space.hpp" 35 #include "memory/universe.hpp" 36 #include "runtime/arguments.hpp" 37 #include "runtime/globals_extension.hpp" 38 #include "runtime/handles.inline.hpp" 39 #include "runtime/java.hpp" 40 #include "runtime/thread.inline.hpp" 41 #include "runtime/vmThread.hpp" 42 #include "utilities/macros.hpp" 43 #if INCLUDE_ALL_GCS 44 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp" 45 #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp" 46 #endif // INCLUDE_ALL_GCS 47 48 // CollectorPolicy methods. 49 50 void CollectorPolicy::initialize_flags() { 51 if (MetaspaceSize > MaxMetaspaceSize) { 52 MaxMetaspaceSize = MetaspaceSize; 53 } 54 MetaspaceSize = MAX2(min_alignment(), align_size_down_(MetaspaceSize, min_alignment())); 55 // Don't increase Metaspace size limit above specified. 56 MaxMetaspaceSize = align_size_down(MaxMetaspaceSize, max_alignment()); 57 if (MetaspaceSize > MaxMetaspaceSize) { 58 MetaspaceSize = MaxMetaspaceSize; 59 } 60 61 MinMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MinMetaspaceExpansion, min_alignment())); 62 MaxMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MaxMetaspaceExpansion, min_alignment())); 63 64 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment()); 65 66 assert(MetaspaceSize % min_alignment() == 0, "metapace alignment"); 67 assert(MaxMetaspaceSize % max_alignment() == 0, "maximum metaspace alignment"); 68 if (MetaspaceSize < 256*K) { 69 vm_exit_during_initialization("Too small initial Metaspace size"); 70 } 71 } 72 73 void CollectorPolicy::initialize_size_info() { 74 // User inputs from -mx and ms are aligned 75 set_initial_heap_byte_size(InitialHeapSize); 76 if (initial_heap_byte_size() == 0) { 77 set_initial_heap_byte_size(NewSize + OldSize); 78 } 79 set_initial_heap_byte_size(align_size_up(_initial_heap_byte_size, 80 min_alignment())); 81 82 set_min_heap_byte_size(Arguments::min_heap_size()); 83 if (min_heap_byte_size() == 0) { 84 set_min_heap_byte_size(NewSize + OldSize); 85 } 86 set_min_heap_byte_size(align_size_up(_min_heap_byte_size, 87 min_alignment())); 88 89 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment())); 90 91 // Check heap parameter properties 92 if (initial_heap_byte_size() < M) { 93 vm_exit_during_initialization("Too small initial heap"); 94 } 95 // Check heap parameter properties 96 if (min_heap_byte_size() < M) { 97 vm_exit_during_initialization("Too small minimum heap"); 98 } 99 if (initial_heap_byte_size() <= NewSize) { 100 // make sure there is at least some room in old space 101 vm_exit_during_initialization("Too small initial heap for new size specified"); 102 } 103 if (max_heap_byte_size() < min_heap_byte_size()) { 104 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified"); 105 } 106 if (initial_heap_byte_size() < min_heap_byte_size()) { 107 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified"); 108 } 216 NewSize = align_size_down(NewSize, min_alignment()); 217 MaxNewSize = align_size_down(MaxNewSize, min_alignment()); 218 219 // Check validity of heap flags 220 assert(NewSize % min_alignment() == 0, "eden space alignment"); 221 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment"); 222 223 if (NewSize < 3*min_alignment()) { 224 // make sure there room for eden and two survivor spaces 225 vm_exit_during_initialization("Too small new size specified"); 226 } 227 if (SurvivorRatio < 1 || NewRatio < 1) { 228 vm_exit_during_initialization("Invalid heap ratio specified"); 229 } 230 } 231 232 void TwoGenerationCollectorPolicy::initialize_flags() { 233 GenCollectorPolicy::initialize_flags(); 234 235 OldSize = align_size_down(OldSize, min_alignment()); 236 if (NewSize + OldSize > MaxHeapSize) { 237 MaxHeapSize = NewSize + OldSize; 238 } 239 240 if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(NewSize)) { 241 // NewRatio will be used later to set the young generation size so we use 242 // it to calculate how big the heap should be based on the requested OldSize 243 // and NewRatio. 244 assert(NewRatio > 0, "NewRatio should have been set up earlier"); 245 size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1); 246 247 calculated_heapsize = align_size_up(calculated_heapsize, max_alignment()); 248 MaxHeapSize = calculated_heapsize; 249 InitialHeapSize = calculated_heapsize; 250 } 251 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment()); 252 253 always_do_update_barrier = UseConcMarkSweepGC; 254 255 // Check validity of heap flags 256 assert(OldSize % min_alignment() == 0, "old space alignment"); 257 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment"); 258 } 259 260 // Values set on the command line win over any ergonomically 261 // set command line parameters. 262 // Ergonomic choice of parameters are done before this 263 // method is called. Values for command line parameters such as NewSize 264 // and MaxNewSize feed those ergonomic choices into this method. 265 // This method makes the final generation sizings consistent with 266 // themselves and with overall heap sizings. 267 // In the absence of explicitly set command line flags, policies 268 // such as the use of NewRatio are used to size the generation. 269 void GenCollectorPolicy::initialize_size_info() { 270 CollectorPolicy::initialize_size_info(); | 31 #include "memory/gcLocker.inline.hpp" 32 #include "memory/genCollectedHeap.hpp" 33 #include "memory/generationSpec.hpp" 34 #include "memory/space.hpp" 35 #include "memory/universe.hpp" 36 #include "runtime/arguments.hpp" 37 #include "runtime/globals_extension.hpp" 38 #include "runtime/handles.inline.hpp" 39 #include "runtime/java.hpp" 40 #include "runtime/thread.inline.hpp" 41 #include "runtime/vmThread.hpp" 42 #include "utilities/macros.hpp" 43 #if INCLUDE_ALL_GCS 44 #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp" 45 #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp" 46 #endif // INCLUDE_ALL_GCS 47 48 // CollectorPolicy methods. 49 50 void CollectorPolicy::initialize_flags() { 51 if (MaxHeapSize < InitialHeapSize) { 52 vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified"); 53 } 54 55 if (MetaspaceSize > MaxMetaspaceSize) { 56 MaxMetaspaceSize = MetaspaceSize; 57 } 58 MetaspaceSize = MAX2(min_alignment(), align_size_down_(MetaspaceSize, min_alignment())); 59 // Don't increase Metaspace size limit above specified. 60 MaxMetaspaceSize = align_size_down(MaxMetaspaceSize, max_alignment()); 61 if (MetaspaceSize > MaxMetaspaceSize) { 62 MetaspaceSize = MaxMetaspaceSize; 63 } 64 65 MinMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MinMetaspaceExpansion, min_alignment())); 66 MaxMetaspaceExpansion = MAX2(min_alignment(), align_size_down_(MaxMetaspaceExpansion, min_alignment())); 67 68 MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment()); 69 70 assert(MetaspaceSize % min_alignment() == 0, "metapace alignment"); 71 assert(MaxMetaspaceSize % max_alignment() == 0, "maximum metaspace alignment"); 72 if (MetaspaceSize < 256*K) { 73 vm_exit_during_initialization("Too small initial Metaspace size"); 74 } 75 } 76 77 void CollectorPolicy::initialize_size_info() { 78 // User inputs from -mx and ms must be aligned 79 set_min_heap_byte_size(align_size_up(Arguments::min_heap_size(), min_alignment())); 80 set_initial_heap_byte_size(align_size_up(InitialHeapSize, min_alignment())); 81 set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment())); 82 83 // Check heap parameter properties 84 if (initial_heap_byte_size() < M) { 85 vm_exit_during_initialization("Too small initial heap"); 86 } 87 // Check heap parameter properties 88 if (min_heap_byte_size() < M) { 89 vm_exit_during_initialization("Too small minimum heap"); 90 } 91 if (initial_heap_byte_size() <= NewSize) { 92 // make sure there is at least some room in old space 93 vm_exit_during_initialization("Too small initial heap for new size specified"); 94 } 95 if (max_heap_byte_size() < min_heap_byte_size()) { 96 vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified"); 97 } 98 if (initial_heap_byte_size() < min_heap_byte_size()) { 99 vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified"); 100 } 208 NewSize = align_size_down(NewSize, min_alignment()); 209 MaxNewSize = align_size_down(MaxNewSize, min_alignment()); 210 211 // Check validity of heap flags 212 assert(NewSize % min_alignment() == 0, "eden space alignment"); 213 assert(MaxNewSize % min_alignment() == 0, "survivor space alignment"); 214 215 if (NewSize < 3*min_alignment()) { 216 // make sure there room for eden and two survivor spaces 217 vm_exit_during_initialization("Too small new size specified"); 218 } 219 if (SurvivorRatio < 1 || NewRatio < 1) { 220 vm_exit_during_initialization("Invalid heap ratio specified"); 221 } 222 } 223 224 void TwoGenerationCollectorPolicy::initialize_flags() { 225 GenCollectorPolicy::initialize_flags(); 226 227 OldSize = align_size_down(OldSize, min_alignment()); 228 229 if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(NewSize)) { 230 // NewRatio will be used later to set the young generation size so we use 231 // it to calculate how big the heap should be based on the requested OldSize 232 // and NewRatio. 233 assert(NewRatio > 0, "NewRatio should have been set up earlier"); 234 size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1); 235 236 calculated_heapsize = align_size_up(calculated_heapsize, max_alignment()); 237 MaxHeapSize = calculated_heapsize; 238 InitialHeapSize = calculated_heapsize; 239 } 240 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment()); 241 242 // adjust max heap size if necessary 243 if (NewSize + OldSize > MaxHeapSize) { 244 if (FLAG_IS_CMDLINE(MaxHeapSize)) { 245 // somebody set a maximum heap size with the intention that we should not 246 // exceed it. Adjust New/OldSize as necessary. 247 uintx calculated_size = NewSize + OldSize; 248 double shrink_factor = (double) MaxHeapSize / calculated_size; 249 // align 250 NewSize = align_size_down((uintx) (NewSize * shrink_factor), min_alignment()); 251 // OldSize is already aligned because above we aligned MaxHeapSize to 252 // max_alignment(), and we just made sure that NewSize is aligned to 253 // min_alignment(). In initialize_flags() we verified that max_alignment() 254 // is a multiple of min_alignment(). 255 OldSize = MaxHeapSize - NewSize; 256 } else { 257 MaxHeapSize = NewSize + OldSize; 258 } 259 } 260 // need to do this again 261 MaxHeapSize = align_size_up(MaxHeapSize, max_alignment()); 262 263 always_do_update_barrier = UseConcMarkSweepGC; 264 265 // Check validity of heap flags 266 assert(OldSize % min_alignment() == 0, "old space alignment"); 267 assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment"); 268 } 269 270 // Values set on the command line win over any ergonomically 271 // set command line parameters. 272 // Ergonomic choice of parameters are done before this 273 // method is called. Values for command line parameters such as NewSize 274 // and MaxNewSize feed those ergonomic choices into this method. 275 // This method makes the final generation sizings consistent with 276 // themselves and with overall heap sizings. 277 // In the absence of explicitly set command line flags, policies 278 // such as the use of NewRatio are used to size the generation. 279 void GenCollectorPolicy::initialize_size_info() { 280 CollectorPolicy::initialize_size_info(); |