Mercurial > hg > graal-jvmci-8
comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 13060:8f07aa079343
8016309: assert(eden_size > 0 && survivor_size > 0) failed: just checking
7057939: jmap shows MaxNewSize=4GB when Java is using parallel collector
Summary: Major cleanup of the collectorpolicy classes
Reviewed-by: tschatzl, jcoomes
author | jwilhelm |
---|---|
date | Fri, 01 Nov 2013 17:09:38 +0100 |
parents | 4288e54fd145 |
children | 284953caf7aa 270d7cb38f40 |
comparison
equal
deleted
inserted
replaced
13059:46d7652b223c | 13060:8f07aa079343 |
---|---|
311 _reserve_factor = (double) reserve_perc / 100.0; | 311 _reserve_factor = (double) reserve_perc / 100.0; |
312 // This will be set when the heap is expanded | 312 // This will be set when the heap is expanded |
313 // for the first time during initialization. | 313 // for the first time during initialization. |
314 _reserve_regions = 0; | 314 _reserve_regions = 0; |
315 | 315 |
316 initialize_all(); | |
317 _collectionSetChooser = new CollectionSetChooser(); | 316 _collectionSetChooser = new CollectionSetChooser(); |
318 _young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags | 317 } |
319 } | 318 |
320 | 319 void G1CollectorPolicy::initialize_alignments() { |
321 void G1CollectorPolicy::initialize_flags() { | 320 _space_alignment = HeapRegion::GrainBytes; |
322 _min_alignment = HeapRegion::GrainBytes; | |
323 size_t card_table_alignment = GenRemSet::max_alignment_constraint(GenRemSet::CardTable); | 321 size_t card_table_alignment = GenRemSet::max_alignment_constraint(GenRemSet::CardTable); |
324 size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size(); | 322 size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size(); |
325 _max_alignment = MAX3(card_table_alignment, _min_alignment, page_size); | 323 _heap_alignment = MAX3(card_table_alignment, _space_alignment, page_size); |
324 } | |
325 | |
326 void G1CollectorPolicy::initialize_flags() { | |
327 if (G1HeapRegionSize != HeapRegion::GrainBytes) { | |
328 FLAG_SET_ERGO(uintx, G1HeapRegionSize, HeapRegion::GrainBytes); | |
329 } | |
330 | |
326 if (SurvivorRatio < 1) { | 331 if (SurvivorRatio < 1) { |
327 vm_exit_during_initialization("Invalid survivor ratio specified"); | 332 vm_exit_during_initialization("Invalid survivor ratio specified"); |
328 } | 333 } |
329 CollectorPolicy::initialize_flags(); | 334 CollectorPolicy::initialize_flags(); |
330 } | 335 _young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags |
331 | 336 } |
332 G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true) { | 337 |
333 assert(G1NewSizePercent <= G1MaxNewSizePercent, "Min larger than max"); | 338 void G1CollectorPolicy::post_heap_initialize() { |
334 assert(G1NewSizePercent > 0 && G1NewSizePercent < 100, "Min out of bounds"); | 339 uintx max_regions = G1CollectedHeap::heap()->max_regions(); |
335 assert(G1MaxNewSizePercent > 0 && G1MaxNewSizePercent < 100, "Max out of bounds"); | 340 size_t max_young_size = (size_t)_young_gen_sizer->max_young_length(max_regions) * HeapRegion::GrainBytes; |
336 | 341 if (max_young_size != MaxNewSize) { |
342 FLAG_SET_ERGO(uintx, MaxNewSize, max_young_size); | |
343 } | |
344 } | |
345 | |
346 G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true), | |
347 _min_desired_young_length(0), _max_desired_young_length(0) { | |
337 if (FLAG_IS_CMDLINE(NewRatio)) { | 348 if (FLAG_IS_CMDLINE(NewRatio)) { |
338 if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) { | 349 if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) { |
339 warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio"); | 350 warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio"); |
340 } else { | 351 } else { |
341 _sizer_kind = SizerNewRatio; | 352 _sizer_kind = SizerNewRatio; |
342 _adaptive_size = false; | 353 _adaptive_size = false; |
343 return; | 354 return; |
344 } | 355 } |
345 } | 356 } |
346 | 357 |
347 if (FLAG_IS_CMDLINE(NewSize) && FLAG_IS_CMDLINE(MaxNewSize) && NewSize > MaxNewSize) { | 358 if (NewSize > MaxNewSize) { |
348 vm_exit_during_initialization("Initial young gen size set larger than the maximum young gen size"); | 359 if (FLAG_IS_CMDLINE(MaxNewSize)) { |
360 warning("NewSize (" SIZE_FORMAT "k) is greater than the MaxNewSize (" SIZE_FORMAT "k). " | |
361 "A new max generation size of " SIZE_FORMAT "k will be used.", | |
362 NewSize/K, MaxNewSize/K, NewSize/K); | |
363 } | |
364 MaxNewSize = NewSize; | |
349 } | 365 } |
350 | 366 |
351 if (FLAG_IS_CMDLINE(NewSize)) { | 367 if (FLAG_IS_CMDLINE(NewSize)) { |
352 _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes), | 368 _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes), |
353 1U); | 369 1U); |
376 uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) { | 392 uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) { |
377 uint default_value = (new_number_of_heap_regions * G1MaxNewSizePercent) / 100; | 393 uint default_value = (new_number_of_heap_regions * G1MaxNewSizePercent) / 100; |
378 return MAX2(1U, default_value); | 394 return MAX2(1U, default_value); |
379 } | 395 } |
380 | 396 |
381 void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) { | 397 void G1YoungGenSizer::recalculate_min_max_young_length(uint number_of_heap_regions, uint* min_young_length, uint* max_young_length) { |
382 assert(new_number_of_heap_regions > 0, "Heap must be initialized"); | 398 assert(number_of_heap_regions > 0, "Heap must be initialized"); |
383 | 399 |
384 switch (_sizer_kind) { | 400 switch (_sizer_kind) { |
385 case SizerDefaults: | 401 case SizerDefaults: |
386 _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions); | 402 *min_young_length = calculate_default_min_length(number_of_heap_regions); |
387 _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions); | 403 *max_young_length = calculate_default_max_length(number_of_heap_regions); |
388 break; | 404 break; |
389 case SizerNewSizeOnly: | 405 case SizerNewSizeOnly: |
390 _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions); | 406 *max_young_length = calculate_default_max_length(number_of_heap_regions); |
391 _max_desired_young_length = MAX2(_min_desired_young_length, _max_desired_young_length); | 407 *max_young_length = MAX2(*min_young_length, *max_young_length); |
392 break; | 408 break; |
393 case SizerMaxNewSizeOnly: | 409 case SizerMaxNewSizeOnly: |
394 _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions); | 410 *min_young_length = calculate_default_min_length(number_of_heap_regions); |
395 _min_desired_young_length = MIN2(_min_desired_young_length, _max_desired_young_length); | 411 *min_young_length = MIN2(*min_young_length, *max_young_length); |
396 break; | 412 break; |
397 case SizerMaxAndNewSize: | 413 case SizerMaxAndNewSize: |
398 // Do nothing. Values set on the command line, don't update them at runtime. | 414 // Do nothing. Values set on the command line, don't update them at runtime. |
399 break; | 415 break; |
400 case SizerNewRatio: | 416 case SizerNewRatio: |
401 _min_desired_young_length = new_number_of_heap_regions / (NewRatio + 1); | 417 *min_young_length = number_of_heap_regions / (NewRatio + 1); |
402 _max_desired_young_length = _min_desired_young_length; | 418 *max_young_length = *min_young_length; |
403 break; | 419 break; |
404 default: | 420 default: |
405 ShouldNotReachHere(); | 421 ShouldNotReachHere(); |
406 } | 422 } |
407 | 423 |
408 assert(_min_desired_young_length <= _max_desired_young_length, "Invalid min/max young gen size values"); | 424 assert(*min_young_length <= *max_young_length, "Invalid min/max young gen size values"); |
425 } | |
426 | |
427 uint G1YoungGenSizer::max_young_length(uint number_of_heap_regions) { | |
428 // We need to pass the desired values because recalculation may not update these | |
429 // values in some cases. | |
430 uint temp = _min_desired_young_length; | |
431 uint result = _max_desired_young_length; | |
432 recalculate_min_max_young_length(number_of_heap_regions, &temp, &result); | |
433 return result; | |
434 } | |
435 | |
436 void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) { | |
437 recalculate_min_max_young_length(new_number_of_heap_regions, &_min_desired_young_length, | |
438 &_max_desired_young_length); | |
409 } | 439 } |
410 | 440 |
411 void G1CollectorPolicy::init() { | 441 void G1CollectorPolicy::init() { |
412 // Set aside an initial future to_space. | 442 // Set aside an initial future to_space. |
413 _g1 = G1CollectedHeap::heap(); | 443 _g1 = G1CollectedHeap::heap(); |