# HG changeset patch # User ysr # Date 1287900229 25200 # Node ID a7214d79fcf1de4d00067cd6f7fddb2811d7f66f # Parent cd3ef3fd20dd421ee2f1469d2cb0801bac314d2e 6896603: CMS/GCH: collection_attempt_is_safe() ergo should use more recent data Summary: Deprecated HandlePromotionFailure, removing the ability to turn off that feature, did away with one epoch look-ahead when deciding if a scavenge is likely to fail, relying on current data. Reviewed-by: jmasa, johnc, poonam diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Sat Oct 23 23:03:49 2010 -0700 @@ -354,12 +354,8 @@ double CMSStats::time_until_cms_gen_full() const { size_t cms_free = _cms_gen->cmsSpace()->free(); GenCollectedHeap* gch = GenCollectedHeap::heap(); - size_t expected_promotion = gch->get_gen(0)->capacity(); - if (HandlePromotionFailure) { - expected_promotion = MIN2( - (size_t) _cms_gen->gc_stats()->avg_promoted()->padded_average(), - expected_promotion); - } + size_t expected_promotion = MIN2(gch->get_gen(0)->capacity(), + (size_t) _cms_gen->gc_stats()->avg_promoted()->padded_average()); if (cms_free > expected_promotion) { // Start a cms collection if there isn't enough space to promote // for the next minor collection. Use the padded average as @@ -865,57 +861,18 @@ return free() + _virtual_space.uncommitted_size(); } -bool ConcurrentMarkSweepGeneration::promotion_attempt_is_safe( - size_t max_promotion_in_bytes, - bool younger_handles_promotion_failure) const { - - // This is the most conservative test. Full promotion is - // guaranteed if this is used. The multiplicative factor is to - // account for the worst case "dilatation". - double adjusted_max_promo_bytes = _dilatation_factor * max_promotion_in_bytes; - if (adjusted_max_promo_bytes > (double)max_uintx) { // larger than size_t - adjusted_max_promo_bytes = (double)max_uintx; - } - bool result = (max_contiguous_available() >= (size_t)adjusted_max_promo_bytes); - - if (younger_handles_promotion_failure && !result) { - // Full promotion is not guaranteed because fragmentation - // of the cms generation can prevent the full promotion. - result = (max_available() >= (size_t)adjusted_max_promo_bytes); - - if (!result) { - // With promotion failure handling the test for the ability - // to support the promotion does not have to be guaranteed. - // Use an average of the amount promoted. - result = max_available() >= (size_t) - gc_stats()->avg_promoted()->padded_average(); - if (PrintGC && Verbose && result) { - gclog_or_tty->print_cr( - "\nConcurrentMarkSweepGeneration::promotion_attempt_is_safe" - " max_available: " SIZE_FORMAT - " avg_promoted: " SIZE_FORMAT, - max_available(), (size_t) - gc_stats()->avg_promoted()->padded_average()); - } - } else { - if (PrintGC && Verbose) { - gclog_or_tty->print_cr( - "\nConcurrentMarkSweepGeneration::promotion_attempt_is_safe" - " max_available: " SIZE_FORMAT - " adj_max_promo_bytes: " SIZE_FORMAT, - max_available(), (size_t)adjusted_max_promo_bytes); - } - } - } else { - if (PrintGC && Verbose) { - gclog_or_tty->print_cr( - "\nConcurrentMarkSweepGeneration::promotion_attempt_is_safe" - " contiguous_available: " SIZE_FORMAT - " adj_max_promo_bytes: " SIZE_FORMAT, - max_contiguous_available(), (size_t)adjusted_max_promo_bytes); - } - } - return result; +bool ConcurrentMarkSweepGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const { + size_t available = max_available(); + size_t av_promo = (size_t)gc_stats()->avg_promoted()->padded_average(); + bool res = (available >= av_promo) || (available >= max_promotion_in_bytes); + if (PrintGC && Verbose) { + gclog_or_tty->print_cr( + "CMS: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT")," + "max_promo("SIZE_FORMAT")", + res? "":" not", available, res? ">=":"<", + av_promo, max_promotion_in_bytes); + } + return res; } // At a promotion failure dump information on block layout in heap @@ -6091,23 +6048,14 @@ assert(_collectorState == Resizing, "Change of collector state to" " Resizing must be done under the freelistLocks (plural)"); - // Now that sweeping has been completed, if the GCH's - // incremental_collection_will_fail flag is set, clear it, + // Now that sweeping has been completed, we clear + // the incremental_collection_failed flag, // thus inviting a younger gen collection to promote into // this generation. If such a promotion may still fail, // the flag will be set again when a young collection is // attempted. - // I think the incremental_collection_will_fail flag's use - // is specific to a 2 generation collection policy, so i'll - // assert that that's the configuration we are operating within. - // The use of the flag can and should be generalized appropriately - // in the future to deal with a general n-generation system. - GenCollectedHeap* gch = GenCollectedHeap::heap(); - assert(gch->collector_policy()->is_two_generation_policy(), - "Resetting of incremental_collection_will_fail flag" - " may be incorrect otherwise"); - gch->clear_incremental_collection_will_fail(); + gch->clear_incremental_collection_failed(); // Worth retrying as fresh space may have been freed up gch->update_full_collections_completed(_collection_count_start); } diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp --- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Sat Oct 23 23:03:49 2010 -0700 @@ -1185,8 +1185,7 @@ virtual void par_promote_alloc_done(int thread_num); virtual void par_oop_since_save_marks_iterate_done(int thread_num); - virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes, - bool younger_handles_promotion_failure) const; + virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes) const; // Inform this (non-young) generation that a promotion failure was // encountered during a collection of a younger generation that diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/gc_implementation/parNew/parNewGeneration.cpp --- a/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Sat Oct 23 23:03:49 2010 -0700 @@ -846,7 +846,7 @@ // from this generation, pass on collection; let the next generation // do it. if (!collection_attempt_is_safe()) { - gch->set_incremental_collection_will_fail(); + gch->set_incremental_collection_failed(); // slight lie, in that we did not even attempt one return; } assert(to()->is_empty(), "Else not collection_attempt_is_safe"); @@ -935,8 +935,6 @@ assert(to()->is_empty(), "to space should be empty now"); } else { - assert(HandlePromotionFailure, - "Should only be here if promotion failure handling is on"); assert(_promo_failure_scan_stack.is_empty(), "post condition"); _promo_failure_scan_stack.clear(true); // Clear cached segments. @@ -947,7 +945,7 @@ // All the spaces are in play for mark-sweep. swap_spaces(); // Make life simpler for CMS || rescan; see 6483690. from()->set_next_compaction_space(to()); - gch->set_incremental_collection_will_fail(); + gch->set_incremental_collection_failed(); // Inform the next generation that a promotion failure occurred. _next_gen->promotion_failure_occurred(); @@ -1092,11 +1090,6 @@ old, m, sz); if (new_obj == NULL) { - if (!HandlePromotionFailure) { - // A failed promotion likely means the MaxLiveObjectEvacuationRatio flag - // is incorrectly set. In any case, its seriously wrong to be here! - vm_exit_out_of_memory(sz*wordSize, "promotion"); - } // promotion failed, forward to self _promotion_failed = true; new_obj = old; @@ -1206,12 +1199,6 @@ old, m, sz); if (new_obj == NULL) { - if (!HandlePromotionFailure) { - // A failed promotion likely means the MaxLiveObjectEvacuationRatio - // flag is incorrectly set. In any case, its seriously wrong to be - // here! - vm_exit_out_of_memory(sz*wordSize, "promotion"); - } // promotion failed, forward to self forward_ptr = old->forward_to_atomic(old); new_obj = old; diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/memory/collectorPolicy.cpp --- a/src/share/vm/memory/collectorPolicy.cpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/memory/collectorPolicy.cpp Sat Oct 23 23:03:49 2010 -0700 @@ -659,9 +659,6 @@ } return result; // could be null if we are out of space } else if (!gch->incremental_collection_will_fail()) { - // The gc_prologues have not executed yet. The value - // for incremental_collection_will_fail() is the remanent - // of the last collection. // Do an incremental collection. gch->do_collection(false /* full */, false /* clear_all_soft_refs */, @@ -739,9 +736,8 @@ GenCollectedHeap* gch = GenCollectedHeap::heap(); size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc(); return (word_size > heap_word_size(gen0_capacity)) - || (GC_locker::is_active_and_needs_gc()) - || ( gch->last_incremental_collection_failed() - && gch->incremental_collection_will_fail()); + || GC_locker::is_active_and_needs_gc() + || gch->incremental_collection_failed(); } diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/memory/defNewGeneration.cpp --- a/src/share/vm/memory/defNewGeneration.cpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/memory/defNewGeneration.cpp Sat Oct 23 23:03:49 2010 -0700 @@ -510,7 +510,7 @@ // from this generation, pass on collection; let the next generation // do it. if (!collection_attempt_is_safe()) { - gch->set_incremental_collection_will_fail(); + gch->set_incremental_collection_failed(); // Slight lie: we did not even attempt one return; } assert(to()->is_empty(), "Else not collection_attempt_is_safe"); @@ -596,9 +596,8 @@ if (PrintGC && !PrintGCDetails) { gch->print_heap_change(gch_prev_used); } + assert(!gch->incremental_collection_failed(), "Should be clear"); } else { - assert(HandlePromotionFailure, - "Should not be here unless promotion failure handling is on"); assert(_promo_failure_scan_stack.is_empty(), "post condition"); _promo_failure_scan_stack.clear(true); // Clear cached segments. @@ -613,7 +612,7 @@ // and from-space. swap_spaces(); // For uniformity wrt ParNewGeneration. from()->set_next_compaction_space(to()); - gch->set_incremental_collection_will_fail(); + gch->set_incremental_collection_failed(); // Inform the next generation that a promotion failure occurred. _next_gen->promotion_failure_occurred(); @@ -700,12 +699,6 @@ if (obj == NULL) { obj = _next_gen->promote(old, s); if (obj == NULL) { - if (!HandlePromotionFailure) { - // A failed promotion likely means the MaxLiveObjectEvacuationRatio flag - // is incorrectly set. In any case, its seriously wrong to be here! - vm_exit_out_of_memory(s*wordSize, "promotion"); - } - handle_promotion_failure(old); return old; } @@ -812,31 +805,7 @@ assert(_next_gen != NULL, "This must be the youngest gen, and not the only gen"); } - - // Decide if there's enough room for a full promotion - // When using extremely large edens, we effectively lose a - // large amount of old space. Use the "MaxLiveObjectEvacuationRatio" - // flag to reduce the minimum evacuation space requirements. If - // there is not enough space to evacuate eden during a scavenge, - // the VM will immediately exit with an out of memory error. - // This flag has not been tested - // with collectors other than simple mark & sweep. - // - // Note that with the addition of promotion failure handling, the - // VM will not immediately exit but will undo the young generation - // collection. The parameter is left here for compatibility. - const double evacuation_ratio = MaxLiveObjectEvacuationRatio / 100.0; - - // worst_case_evacuation is based on "used()". For the case where this - // method is called after a collection, this is still appropriate because - // the case that needs to be detected is one in which a full collection - // has been done and has overflowed into the young generation. In that - // case a minor collection will fail (the overflow of the full collection - // means there is no space in the old generation for any promotion). - size_t worst_case_evacuation = (size_t)(used() * evacuation_ratio); - - return _next_gen->promotion_attempt_is_safe(worst_case_evacuation, - HandlePromotionFailure); + return _next_gen->promotion_attempt_is_safe(used()); } void DefNewGeneration::gc_epilogue(bool full) { @@ -845,14 +814,17 @@ // a minimum at the end of a collection. If it is not, then // the heap is approaching full. GenCollectedHeap* gch = GenCollectedHeap::heap(); - clear_should_allocate_from_space(); - if (collection_attempt_is_safe()) { - gch->clear_incremental_collection_will_fail(); + if (full) { + assert(!GC_locker::is_active(), "We should not be executing here"); + if (!collection_attempt_is_safe()) { + gch->set_incremental_collection_failed(); // Slight lie: a full gc left us in that state + set_should_allocate_from_space(); // we seem to be running out of space + } else { + gch->clear_incremental_collection_failed(); // We just did a full collection + clear_should_allocate_from_space(); // if set + } } else { - gch->set_incremental_collection_will_fail(); - if (full) { // we seem to be running out of space - set_should_allocate_from_space(); - } + assert(!gch->incremental_collection_failed(), "Error"); } if (ZapUnusedHeapArea) { diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/memory/defNewGeneration.hpp --- a/src/share/vm/memory/defNewGeneration.hpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/memory/defNewGeneration.hpp Sat Oct 23 23:03:49 2010 -0700 @@ -82,12 +82,6 @@ Stack _objs_with_preserved_marks; Stack _preserved_marks_of_objs; - // Returns true if the collection can be safely attempted. - // If this method returns false, a collection is not - // guaranteed to fail but the system may not be able - // to recover from the failure. - bool collection_attempt_is_safe(); - // Promotion failure handling OopClosure *_promo_failure_scan_stack_closure; void set_promo_failure_scan_stack_closure(OopClosure *scan_stack_closure) { @@ -304,6 +298,14 @@ // GC support virtual void compute_new_size(); + + // Returns true if the collection is likely to be safely + // completed. Even if this method returns true, a collection + // may not be guaranteed to succeed, and the system should be + // able to safely unwind and recover from that failure, albeit + // at some additional cost. Override superclass's implementation. + virtual bool collection_attempt_is_safe(); + virtual void collect(bool full, bool clear_all_soft_refs, size_t size, diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/memory/genCollectedHeap.cpp --- a/src/share/vm/memory/genCollectedHeap.cpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/memory/genCollectedHeap.cpp Sat Oct 23 23:03:49 2010 -0700 @@ -142,8 +142,7 @@ } _perm_gen = perm_gen_spec->init(heap_rs, PermSize, rem_set()); - clear_incremental_collection_will_fail(); - clear_last_incremental_collection_failed(); + clear_incremental_collection_failed(); #ifndef SERIALGC // If we are running CMS, create the collector responsible @@ -1347,17 +1346,6 @@ }; void GenCollectedHeap::gc_epilogue(bool full) { - // Remember if a partial collection of the heap failed, and - // we did a complete collection. - if (full && incremental_collection_will_fail()) { - set_last_incremental_collection_failed(); - } else { - clear_last_incremental_collection_failed(); - } - // Clear the flag, if set; the generation gc_epilogues will set the - // flag again if the condition persists despite the collection. - clear_incremental_collection_will_fail(); - #ifdef COMPILER2 assert(DerivedPointerTable::is_empty(), "derived pointer present"); size_t actual_gap = pointer_delta((HeapWord*) (max_uintx-3), *(end_addr())); diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/memory/genCollectedHeap.hpp --- a/src/share/vm/memory/genCollectedHeap.hpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/memory/genCollectedHeap.hpp Sat Oct 23 23:03:49 2010 -0700 @@ -62,11 +62,10 @@ // The generational collector policy. GenCollectorPolicy* _gen_policy; - // If a generation would bail out of an incremental collection, - // it sets this flag. If the flag is set, satisfy_failed_allocation - // will attempt allocating in all generations before doing a full GC. - bool _incremental_collection_will_fail; - bool _last_incremental_collection_failed; + // Indicates that the most recent previous incremental collection failed. + // The flag is cleared when an action is taken that might clear the + // condition that caused that incremental collection to fail. + bool _incremental_collection_failed; // In support of ExplicitGCInvokesConcurrent functionality unsigned int _full_collections_completed; @@ -469,26 +468,26 @@ // call to "save_marks". bool no_allocs_since_save_marks(int level); + // Returns true if an incremental collection is likely to fail. + bool incremental_collection_will_fail() { + // Assumes a 2-generation system; the first disjunct remembers if an + // incremental collection failed, even when we thought (second disjunct) + // that it would not. + assert(heap()->collector_policy()->is_two_generation_policy(), + "the following definition may not be suitable for an n(>2)-generation system"); + return incremental_collection_failed() || !get_gen(0)->collection_attempt_is_safe(); + } + // If a generation bails out of an incremental collection, // it sets this flag. - bool incremental_collection_will_fail() { - return _incremental_collection_will_fail; - } - void set_incremental_collection_will_fail() { - _incremental_collection_will_fail = true; - } - void clear_incremental_collection_will_fail() { - _incremental_collection_will_fail = false; + bool incremental_collection_failed() const { + return _incremental_collection_failed; } - - bool last_incremental_collection_failed() const { - return _last_incremental_collection_failed; + void set_incremental_collection_failed() { + _incremental_collection_failed = true; } - void set_last_incremental_collection_failed() { - _last_incremental_collection_failed = true; - } - void clear_last_incremental_collection_failed() { - _last_incremental_collection_failed = false; + void clear_incremental_collection_failed() { + _incremental_collection_failed = false; } // Promotion of obj into gen failed. Try to promote obj to higher non-perm diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/memory/generation.cpp --- a/src/share/vm/memory/generation.cpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/memory/generation.cpp Sat Oct 23 23:03:49 2010 -0700 @@ -165,15 +165,16 @@ return max; } -bool Generation::promotion_attempt_is_safe(size_t promotion_in_bytes, - bool not_used) const { +bool Generation::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const { + size_t available = max_contiguous_available(); + bool res = (available >= max_promotion_in_bytes); if (PrintGC && Verbose) { - gclog_or_tty->print_cr("Generation::promotion_attempt_is_safe" - " contiguous_available: " SIZE_FORMAT - " promotion_in_bytes: " SIZE_FORMAT, - max_contiguous_available(), promotion_in_bytes); + gclog_or_tty->print_cr( + "Generation: promo attempt is%s safe: available("SIZE_FORMAT") %s max_promo("SIZE_FORMAT")", + res? "":" not", available, res? ">=":"<", + max_promotion_in_bytes); } - return max_contiguous_available() >= promotion_in_bytes; + return res; } // Ignores "ref" and calls allocate(). diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/memory/generation.hpp --- a/src/share/vm/memory/generation.hpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/memory/generation.hpp Sat Oct 23 23:03:49 2010 -0700 @@ -173,15 +173,11 @@ // The largest number of contiguous free bytes in this or any higher generation. virtual size_t max_contiguous_available() const; - // Returns true if promotions of the specified amount can - // be attempted safely (without a vm failure). + // Returns true if promotions of the specified amount are + // likely to succeed without a promotion failure. // Promotion of the full amount is not guaranteed but - // can be attempted. - // younger_handles_promotion_failure - // is true if the younger generation handles a promotion - // failure. - virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes, - bool younger_handles_promotion_failure) const; + // might be attempted in the worst case. + virtual bool promotion_attempt_is_safe(size_t max_promotion_in_bytes) const; // For a non-young generation, this interface can be used to inform a // generation that a promotion attempt into that generation failed. @@ -358,6 +354,16 @@ return (full || should_allocate(word_size, is_tlab)); } + // Returns true if the collection is likely to be safely + // completed. Even if this method returns true, a collection + // may not be guaranteed to succeed, and the system should be + // able to safely unwind and recover from that failure, albeit + // at some additional cost. + virtual bool collection_attempt_is_safe() { + guarantee(false, "Are you sure you want to call this method?"); + return true; + } + // Perform a garbage collection. // If full is true attempt a full garbage collection of this generation. // Otherwise, attempting to (at least) free enough space to support an diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/memory/tenuredGeneration.cpp --- a/src/share/vm/memory/tenuredGeneration.cpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/memory/tenuredGeneration.cpp Sat Oct 23 23:03:49 2010 -0700 @@ -419,29 +419,16 @@ void TenuredGeneration::verify_alloc_buffers_clean() {} #endif // SERIALGC -bool TenuredGeneration::promotion_attempt_is_safe( - size_t max_promotion_in_bytes, - bool younger_handles_promotion_failure) const { - - bool result = max_contiguous_available() >= max_promotion_in_bytes; - - if (younger_handles_promotion_failure && !result) { - result = max_contiguous_available() >= - (size_t) gc_stats()->avg_promoted()->padded_average(); - if (PrintGC && Verbose && result) { - gclog_or_tty->print_cr("TenuredGeneration::promotion_attempt_is_safe" - " contiguous_available: " SIZE_FORMAT - " avg_promoted: " SIZE_FORMAT, - max_contiguous_available(), - gc_stats()->avg_promoted()->padded_average()); - } - } else { - if (PrintGC && Verbose) { - gclog_or_tty->print_cr("TenuredGeneration::promotion_attempt_is_safe" - " contiguous_available: " SIZE_FORMAT - " promotion_in_bytes: " SIZE_FORMAT, - max_contiguous_available(), max_promotion_in_bytes); - } +bool TenuredGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const { + size_t available = max_contiguous_available(); + size_t av_promo = (size_t)gc_stats()->avg_promoted()->padded_average(); + bool res = (available >= av_promo) || (available >= max_promotion_in_bytes); + if (PrintGC && Verbose) { + gclog_or_tty->print_cr( + "Tenured: promo attempt is%s safe: available("SIZE_FORMAT") %s av_promo("SIZE_FORMAT")," + "max_promo("SIZE_FORMAT")", + res? "":" not", available, res? ">=":"<", + av_promo, max_promotion_in_bytes); } - return result; + return res; } diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/memory/tenuredGeneration.hpp --- a/src/share/vm/memory/tenuredGeneration.hpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/memory/tenuredGeneration.hpp Sat Oct 23 23:03:49 2010 -0700 @@ -101,8 +101,7 @@ virtual void update_gc_stats(int level, bool full); - virtual bool promotion_attempt_is_safe(size_t max_promoted_in_bytes, - bool younger_handles_promotion_failure) const; + virtual bool promotion_attempt_is_safe(size_t max_promoted_in_bytes) const; void verify_alloc_buffers_clean(); }; diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/runtime/arguments.cpp --- a/src/share/vm/runtime/arguments.cpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/runtime/arguments.cpp Sat Oct 23 23:03:49 2010 -0700 @@ -185,6 +185,10 @@ JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) }, { "UseDepthFirstScavengeOrder", JDK_Version::jdk_update(6,22), JDK_Version::jdk(7) }, + { "HandlePromotionFailure", + JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) }, + { "MaxLiveObjectEvacuationRatio", + JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) }, { NULL, JDK_Version(0), JDK_Version(0) } }; @@ -1722,8 +1726,6 @@ status = false; } - status = status && verify_percentage(MaxLiveObjectEvacuationRatio, - "MaxLiveObjectEvacuationRatio"); status = status && verify_percentage(AdaptiveSizePolicyWeight, "AdaptiveSizePolicyWeight"); status = status && verify_percentage(AdaptivePermSizeWeight, "AdaptivePermSizeWeight"); diff -r cd3ef3fd20dd -r a7214d79fcf1 src/share/vm/runtime/globals.hpp --- a/src/share/vm/runtime/globals.hpp Thu Oct 21 17:29:24 2010 -0700 +++ b/src/share/vm/runtime/globals.hpp Sat Oct 23 23:03:49 2010 -0700 @@ -1786,10 +1786,6 @@ notproduct(bool, GCALotAtAllSafepoints, false, \ "Enforce ScavengeALot/GCALot at all potential safepoints") \ \ - product(bool, HandlePromotionFailure, true, \ - "The youngest generation collection does not require " \ - "a guarantee of full promotion of all live objects.") \ - \ product(bool, PrintPromotionFailure, false, \ "Print additional diagnostic information following " \ " promotion failure") \ @@ -3003,9 +2999,6 @@ product(intx, NewRatio, 2, \ "Ratio of new/old generation sizes") \ \ - product(uintx, MaxLiveObjectEvacuationRatio, 100, \ - "Max percent of eden objects that will be live at scavenge") \ - \ product_pd(uintx, NewSizeThreadIncrease, \ "Additional size added to desired new generation size per " \ "non-daemon thread (in bytes)") \