307 reserve_perc = 50;
308 warning("G1ReservePercent is set to a value that is too large, "
309 "it's been updated to %u", reserve_perc);
310 }
311 _reserve_factor = (double) reserve_perc / 100.0;
312 // This will be set when the heap is expanded
313 // for the first time during initialization.
314 _reserve_regions = 0;
315
316 initialize_all();
317 _collectionSetChooser = new CollectionSetChooser();
318 _young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags
319 }
320
321 void G1CollectorPolicy::initialize_flags() {
322 _min_alignment = HeapRegion::GrainBytes;
323 size_t card_table_alignment = GenRemSet::max_alignment_constraint(rem_set_name());
324 size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size();
325 _max_alignment = MAX3(card_table_alignment, _min_alignment, page_size);
326
327 if (SurvivorRatio < 1) {
328 vm_exit_during_initialization("Invalid survivor ratio specified");
329 }
330 CollectorPolicy::initialize_flags();
331 }
332
333 G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true) {
334 assert(G1NewSizePercent <= G1MaxNewSizePercent, "Min larger than max");
335 assert(G1NewSizePercent > 0 && G1NewSizePercent < 100, "Min out of bounds");
336 assert(G1MaxNewSizePercent > 0 && G1MaxNewSizePercent < 100, "Max out of bounds");
337
338 if (FLAG_IS_CMDLINE(NewRatio)) {
339 if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) {
340 warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio");
341 } else {
342 _sizer_kind = SizerNewRatio;
343 _adaptive_size = false;
344 return;
345 }
346 }
347
348 if (FLAG_IS_CMDLINE(NewSize)) {
349 _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes),
350 1U);
351 if (FLAG_IS_CMDLINE(MaxNewSize)) {
352 _max_desired_young_length =
353 MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
354 1U);
355 _sizer_kind = SizerMaxAndNewSize;
356 _adaptive_size = _min_desired_young_length == _max_desired_young_length;
357 } else {
358 _sizer_kind = SizerNewSizeOnly;
359 }
360 } else if (FLAG_IS_CMDLINE(MaxNewSize)) {
361 _max_desired_young_length =
362 MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
363 1U);
364 _sizer_kind = SizerMaxNewSizeOnly;
365 }
366 }
367
368 uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) {
369 uint default_value = (new_number_of_heap_regions * G1NewSizePercent) / 100;
370 return MAX2(1U, default_value);
371 }
372
373 uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) {
374 uint default_value = (new_number_of_heap_regions * G1MaxNewSizePercent) / 100;
375 return MAX2(1U, default_value);
376 }
377
378 void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) {
379 assert(new_number_of_heap_regions > 0, "Heap must be initialized");
380
381 switch (_sizer_kind) {
382 case SizerDefaults:
383 _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions);
384 _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions);
385 break;
386 case SizerNewSizeOnly:
387 _max_desired_young_length = calculate_default_max_length(new_number_of_heap_regions);
388 _max_desired_young_length = MAX2(_min_desired_young_length, _max_desired_young_length);
389 break;
390 case SizerMaxNewSizeOnly:
391 _min_desired_young_length = calculate_default_min_length(new_number_of_heap_regions);
392 _min_desired_young_length = MIN2(_min_desired_young_length, _max_desired_young_length);
393 break;
394 case SizerMaxAndNewSize:
395 // Do nothing. Values set on the command line, don't update them at runtime.
396 break;
397 case SizerNewRatio:
398 _min_desired_young_length = new_number_of_heap_regions / (NewRatio + 1);
399 _max_desired_young_length = _min_desired_young_length;
400 break;
401 default:
402 ShouldNotReachHere();
403 }
404
405 assert(_min_desired_young_length <= _max_desired_young_length, "Invalid min/max young gen size values");
406 }
407
408 void G1CollectorPolicy::init() {
409 // Set aside an initial future to_space.
410 _g1 = G1CollectedHeap::heap();
411
412 assert(Heap_lock->owned_by_self(), "Locking discipline.");
413
414 initialize_gc_policy_counters();
415
416 if (adaptive_young_list_length()) {
417 _young_list_fixed_length = 0;
418 } else {
419 _young_list_fixed_length = _young_gen_sizer->min_desired_young_length();
420 }
421 _free_regions_at_end_of_collection = _g1->free_regions();
422 update_young_list_target_length();
423
424 // We may immediately start allocating regions and placing them on the
425 // collection set list. Initialize the per-collection set info
|
307 reserve_perc = 50;
308 warning("G1ReservePercent is set to a value that is too large, "
309 "it's been updated to %u", reserve_perc);
310 }
311 _reserve_factor = (double) reserve_perc / 100.0;
312 // This will be set when the heap is expanded
313 // for the first time during initialization.
314 _reserve_regions = 0;
315
316 initialize_all();
317 _collectionSetChooser = new CollectionSetChooser();
318 _young_gen_sizer = new G1YoungGenSizer(); // Must be after call to initialize_flags
319 }
320
321 void G1CollectorPolicy::initialize_flags() {
322 _min_alignment = HeapRegion::GrainBytes;
323 size_t card_table_alignment = GenRemSet::max_alignment_constraint(rem_set_name());
324 size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size();
325 _max_alignment = MAX3(card_table_alignment, _min_alignment, page_size);
326
327 if (G1HeapRegionSize != HeapRegion::GrainBytes) {
328 FLAG_SET_ERGO(uintx, G1HeapRegionSize, HeapRegion::GrainBytes);
329 }
330
331 if (SurvivorRatio < 1) {
332 vm_exit_during_initialization("Invalid survivor ratio specified");
333 }
334 CollectorPolicy::initialize_flags();
335 }
336
337 void G1CollectorPolicy::post_heap_initialize() {
338 uintx max_regions = G1CollectedHeap::heap()->max_regions();
339 size_t max_young_size = (size_t)_young_gen_sizer->max_young_length(max_regions) * HeapRegion::GrainBytes;
340 if (max_young_size != MaxNewSize) {
341 FLAG_SET_ERGO(uintx, MaxNewSize, max_young_size);
342 }
343 }
344
345 G1YoungGenSizer::G1YoungGenSizer() : _sizer_kind(SizerDefaults), _adaptive_size(true),
346 _min_desired_young_length(0), _max_desired_young_length(0) {
347 if (FLAG_IS_CMDLINE(NewRatio)) {
348 if (FLAG_IS_CMDLINE(NewSize) || FLAG_IS_CMDLINE(MaxNewSize)) {
349 warning("-XX:NewSize and -XX:MaxNewSize override -XX:NewRatio");
350 } else {
351 _sizer_kind = SizerNewRatio;
352 _adaptive_size = false;
353 return;
354 }
355 }
356
357 if (FLAG_IS_CMDLINE(NewSize)) {
358 _min_desired_young_length = MAX2((uint) (NewSize / HeapRegion::GrainBytes),
359 1U);
360 if (FLAG_IS_CMDLINE(MaxNewSize)) {
361 _max_desired_young_length =
362 MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
363 1U);
364 _sizer_kind = SizerMaxAndNewSize;
365 _adaptive_size = _min_desired_young_length == _max_desired_young_length;
366 } else {
367 _sizer_kind = SizerNewSizeOnly;
368 }
369 } else if (FLAG_IS_CMDLINE(MaxNewSize)) {
370 _max_desired_young_length =
371 MAX2((uint) (MaxNewSize / HeapRegion::GrainBytes),
372 1U);
373 _sizer_kind = SizerMaxNewSizeOnly;
374 }
375 }
376
377 uint G1YoungGenSizer::calculate_default_min_length(uint new_number_of_heap_regions) {
378 uint default_value = (new_number_of_heap_regions * G1NewSizePercent) / 100;
379 return MAX2(1U, default_value);
380 }
381
382 uint G1YoungGenSizer::calculate_default_max_length(uint new_number_of_heap_regions) {
383 uint default_value = (new_number_of_heap_regions * G1MaxNewSizePercent) / 100;
384 return MAX2(1U, default_value);
385 }
386
387 void G1YoungGenSizer::recalculate_min_max_young_length(uint number_of_heap_regions, uint* min_young_length, uint* max_young_length) {
388 assert(number_of_heap_regions > 0, "Heap must be initialized");
389
390 switch (_sizer_kind) {
391 case SizerDefaults:
392 *min_young_length = calculate_default_min_length(number_of_heap_regions);
393 *max_young_length = calculate_default_max_length(number_of_heap_regions);
394 break;
395 case SizerNewSizeOnly:
396 *max_young_length = calculate_default_max_length(number_of_heap_regions);
397 *max_young_length = MAX2(*min_young_length, *max_young_length);
398 break;
399 case SizerMaxNewSizeOnly:
400 *min_young_length = calculate_default_min_length(number_of_heap_regions);
401 *min_young_length = MIN2(*min_young_length, *max_young_length);
402 break;
403 case SizerMaxAndNewSize:
404 // Do nothing. Values set on the command line, don't update them at runtime.
405 break;
406 case SizerNewRatio:
407 *min_young_length = number_of_heap_regions / (NewRatio + 1);
408 *max_young_length = *min_young_length;
409 break;
410 default:
411 ShouldNotReachHere();
412 }
413
414 assert(*min_young_length <= *max_young_length, "Invalid min/max young gen size values");
415 }
416
417 uint G1YoungGenSizer::max_young_length(uint number_of_heap_regions) {
418 // We need to pass the desired values because recalculation may not update these
419 // values in some cases.
420 uint temp = _min_desired_young_length;
421 uint result = _max_desired_young_length;
422 recalculate_min_max_young_length(number_of_heap_regions, &temp, &result);
423 return result;
424 }
425
426 void G1YoungGenSizer::heap_size_changed(uint new_number_of_heap_regions) {
427 recalculate_min_max_young_length(new_number_of_heap_regions, &_min_desired_young_length,
428 &_max_desired_young_length);
429 }
430
431 void G1CollectorPolicy::init() {
432 // Set aside an initial future to_space.
433 _g1 = G1CollectedHeap::heap();
434
435 assert(Heap_lock->owned_by_self(), "Locking discipline.");
436
437 initialize_gc_policy_counters();
438
439 if (adaptive_young_list_length()) {
440 _young_list_fixed_length = 0;
441 } else {
442 _young_list_fixed_length = _young_gen_sizer->min_desired_young_length();
443 }
444 _free_regions_at_end_of_collection = _g1->free_regions();
445 update_young_list_target_length();
446
447 // We may immediately start allocating regions and placing them on the
448 // collection set list. Initialize the per-collection set info
|