Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 13060:8f07aa079343

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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();