182 set_change_old_gen_for_min_pauses(0); |
182 set_change_old_gen_for_min_pauses(0); |
183 |
183 |
184 set_change_young_gen_for_maj_pauses(0); |
184 set_change_young_gen_for_maj_pauses(0); |
185 } |
185 } |
186 |
186 |
187 |
|
188 // If this is not a full GC, only test and modify the young generation. |
187 // If this is not a full GC, only test and modify the young generation. |
189 |
188 |
190 void PSAdaptiveSizePolicy::compute_generation_free_space(size_t young_live, |
189 void PSAdaptiveSizePolicy::compute_generation_free_space( |
191 size_t eden_live, |
190 size_t young_live, |
192 size_t old_live, |
191 size_t eden_live, |
193 size_t perm_live, |
192 size_t old_live, |
194 size_t cur_eden, |
193 size_t perm_live, |
195 size_t max_old_gen_size, |
194 size_t cur_eden, |
196 size_t max_eden_size, |
195 size_t max_old_gen_size, |
197 bool is_full_gc, |
196 size_t max_eden_size, |
198 GCCause::Cause gc_cause) { |
197 bool is_full_gc, |
|
198 GCCause::Cause gc_cause, |
|
199 CollectorPolicy* collector_policy) { |
199 |
200 |
200 // Update statistics |
201 // Update statistics |
201 // Time statistics are updated as we go, update footprint stats here |
202 // Time statistics are updated as we go, update footprint stats here |
202 _avg_base_footprint->sample(BaseFootPrintEstimate + perm_live); |
203 _avg_base_footprint->sample(BaseFootPrintEstimate + perm_live); |
203 avg_young_live()->sample(young_live); |
204 avg_young_live()->sample(young_live); |
378 promo_limit = align_size_down(promo_limit, alignment); |
379 promo_limit = align_size_down(promo_limit, alignment); |
379 |
380 |
380 // Is too much time being spent in GC? |
381 // Is too much time being spent in GC? |
381 // Is the heap trying to grow beyond it's limits? |
382 // Is the heap trying to grow beyond it's limits? |
382 |
383 |
383 const size_t free_in_old_gen = (size_t)(max_old_gen_size - avg_old_live()->average()); |
384 const size_t free_in_old_gen = |
|
385 (size_t)(max_old_gen_size - avg_old_live()->average()); |
384 if (desired_promo_size > free_in_old_gen && desired_eden_size > eden_limit) { |
386 if (desired_promo_size > free_in_old_gen && desired_eden_size > eden_limit) { |
385 |
387 check_gc_overhead_limit(young_live, |
386 // eden_limit is the upper limit on the size of eden based on |
388 eden_live, |
387 // the maximum size of the young generation and the sizes |
389 max_old_gen_size, |
388 // of the survivor space. |
390 max_eden_size, |
389 // The question being asked is whether the gc costs are high |
391 is_full_gc, |
390 // and the space being recovered by a collection is low. |
392 gc_cause, |
391 // free_in_young_gen is the free space in the young generation |
393 collector_policy); |
392 // after a collection and promo_live is the free space in the old |
|
393 // generation after a collection. |
|
394 // |
|
395 // Use the minimum of the current value of the live in the |
|
396 // young gen or the average of the live in the young gen. |
|
397 // If the current value drops quickly, that should be taken |
|
398 // into account (i.e., don't trigger if the amount of free |
|
399 // space has suddenly jumped up). If the current is much |
|
400 // higher than the average, use the average since it represents |
|
401 // the longer term behavor. |
|
402 const size_t live_in_eden = MIN2(eden_live, (size_t) avg_eden_live()->average()); |
|
403 const size_t free_in_eden = eden_limit > live_in_eden ? |
|
404 eden_limit - live_in_eden : 0; |
|
405 const size_t total_free_limit = free_in_old_gen + free_in_eden; |
|
406 const size_t total_mem = max_old_gen_size + max_eden_size; |
|
407 const double mem_free_limit = total_mem * (GCHeapFreeLimit/100.0); |
|
408 if (PrintAdaptiveSizePolicy && (Verbose || |
|
409 (total_free_limit < (size_t) mem_free_limit))) { |
|
410 gclog_or_tty->print_cr( |
|
411 "PSAdaptiveSizePolicy::compute_generation_free_space limits:" |
|
412 " promo_limit: " SIZE_FORMAT |
|
413 " eden_limit: " SIZE_FORMAT |
|
414 " total_free_limit: " SIZE_FORMAT |
|
415 " max_old_gen_size: " SIZE_FORMAT |
|
416 " max_eden_size: " SIZE_FORMAT |
|
417 " mem_free_limit: " SIZE_FORMAT, |
|
418 promo_limit, eden_limit, total_free_limit, |
|
419 max_old_gen_size, max_eden_size, |
|
420 (size_t) mem_free_limit); |
|
421 } |
|
422 |
|
423 if (is_full_gc) { |
|
424 if (gc_cost() > gc_cost_limit && |
|
425 total_free_limit < (size_t) mem_free_limit) { |
|
426 // Collections, on average, are taking too much time, and |
|
427 // gc_cost() > gc_cost_limit |
|
428 // we have too little space available after a full gc. |
|
429 // total_free_limit < mem_free_limit |
|
430 // where |
|
431 // total_free_limit is the free space available in |
|
432 // both generations |
|
433 // total_mem is the total space available for allocation |
|
434 // in both generations (survivor spaces are not included |
|
435 // just as they are not included in eden_limit). |
|
436 // mem_free_limit is a fraction of total_mem judged to be an |
|
437 // acceptable amount that is still unused. |
|
438 // The heap can ask for the value of this variable when deciding |
|
439 // whether to thrown an OutOfMemory error. |
|
440 // Note that the gc time limit test only works for the collections |
|
441 // of the young gen + tenured gen and not for collections of the |
|
442 // permanent gen. That is because the calculation of the space |
|
443 // freed by the collection is the free space in the young gen + |
|
444 // tenured gen. |
|
445 // Ignore explicit GC's. Ignoring explicit GC's at this level |
|
446 // is the equivalent of the GC did not happen as far as the |
|
447 // overhead calculation is concerted (i.e., the flag is not set |
|
448 // and the count is not affected). Also the average will not |
|
449 // have been updated unless UseAdaptiveSizePolicyWithSystemGC is on. |
|
450 if (!GCCause::is_user_requested_gc(gc_cause) && |
|
451 !GCCause::is_serviceability_requested_gc(gc_cause)) { |
|
452 inc_gc_time_limit_count(); |
|
453 if (UseGCOverheadLimit && |
|
454 (gc_time_limit_count() > AdaptiveSizePolicyGCTimeLimitThreshold)){ |
|
455 // All conditions have been met for throwing an out-of-memory |
|
456 _gc_time_limit_exceeded = true; |
|
457 // Avoid consecutive OOM due to the gc time limit by resetting |
|
458 // the counter. |
|
459 reset_gc_time_limit_count(); |
|
460 } |
|
461 _print_gc_time_limit_would_be_exceeded = true; |
|
462 } |
|
463 } else { |
|
464 // Did not exceed overhead limits |
|
465 reset_gc_time_limit_count(); |
|
466 } |
|
467 } |
|
468 } |
394 } |
469 |
395 |
470 |
396 |
471 // And one last limit check, now that we've aligned things. |
397 // And one last limit check, now that we've aligned things. |
472 if (desired_eden_size > eden_limit) { |
398 if (desired_eden_size > eden_limit) { |