Mercurial > hg > openjdk > jdk6 > hotspot
changeset 3117:45485117e6b9
Merge
| author | jcoomes |
|---|---|
| date | Tue, 06 Sep 2011 21:29:34 -0700 |
| parents | 8580b4f22e29 (current diff) 5c123cbeebbe (diff) |
| children | 43252bd4c09d |
| files | .hgtags make/hotspot_version |
| diffstat | 14 files changed, 212 insertions(+), 404 deletions(-) [+] |
line wrap: on
line diff
--- a/.hgtags Tue Aug 23 21:17:02 2011 -0700 +++ b/.hgtags Tue Sep 06 21:29:34 2011 -0700 @@ -183,3 +183,10 @@ 81d815b05abb564aa1f4100ae13491c949b9a07e jdk7-b147 81d815b05abb564aa1f4100ae13491c949b9a07e hs21-b17 9b0ca45cd756d538c4c30afab280a91868eee1a5 jdk7u2-b01 +0cc8a70952c368e06de2adab1f2649a408f5e577 jdk8-b01 +31e253c1da429124bb87570ab095d9bc89850d0a jdk8-b02 +3a2fb61165dfc72e398179a2796d740c8da5b8c0 jdk8-b03 +0cc8a70952c368e06de2adab1f2649a408f5e577 hs22-b01 +7c29742c41b44fb0cd5a13c7ac8834f3f2ca649e hs22-b02 +3a2fb61165dfc72e398179a2796d740c8da5b8c0 hs22-b03 +ce9bde819dcba4a5d2822229d9183e69c74326ca hs22-b04
--- a/make/hotspot_version Tue Aug 23 21:17:02 2011 -0700 +++ b/make/hotspot_version Tue Sep 06 21:29:34 2011 -0700 @@ -35,7 +35,7 @@ HS_MAJOR_VER=22 HS_MINOR_VER=0 -HS_BUILD_NUMBER=02 +HS_BUILD_NUMBER=04 JDK_MAJOR_VER=1 JDK_MINOR_VER=8
--- a/src/cpu/x86/vm/assembler_x86.cpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/cpu/x86/vm/assembler_x86.cpp Tue Sep 06 21:29:34 2011 -0700 @@ -2307,7 +2307,7 @@ } void Assembler::prefetchnta(Address src) { - NOT_LP64(assert(VM_Version::supports_sse2(), "must support")); + NOT_LP64(assert(VM_Version::supports_sse(), "must support")); InstructionMark im(this); prefetch_prefix(src); emit_byte(0x18);
--- a/src/share/tools/ProjectCreator/WinGammaPlatformVC10.java Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/tools/ProjectCreator/WinGammaPlatformVC10.java Tue Sep 06 21:29:34 2011 -0700 @@ -482,7 +482,7 @@ "/export:JVM_GetThreadStateNames "+ "/export:JVM_GetThreadStateValues "+ "/export:JVM_InitAgentProperties"); - addAttr(rv, "AdditionalDependencies", "kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;Wsock32.lib;winmm.lib"); + addAttr(rv, "AdditionalDependencies", "kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;Wsock32.lib;winmm.lib;psapi.lib"); addAttr(rv, "OutputFile", outDll); addAttr(rv, "SuppressStartupBanner", "true"); addAttr(rv, "ModuleDefinitionFile", outDir+Util.sep+"vm.def");
--- a/src/share/vm/gc_implementation/g1/concurrentMark.cpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.cpp Tue Sep 06 21:29:34 2011 -0700 @@ -801,39 +801,6 @@ reset(); } -class CMMarkRootsClosure: public OopsInGenClosure { -private: - ConcurrentMark* _cm; - G1CollectedHeap* _g1h; - bool _do_barrier; - -public: - CMMarkRootsClosure(ConcurrentMark* cm, - G1CollectedHeap* g1h, - bool do_barrier) : _cm(cm), _g1h(g1h), - _do_barrier(do_barrier) { } - - virtual void do_oop(narrowOop* p) { do_oop_work(p); } - virtual void do_oop( oop* p) { do_oop_work(p); } - - template <class T> void do_oop_work(T* p) { - T heap_oop = oopDesc::load_heap_oop(p); - if (!oopDesc::is_null(heap_oop)) { - oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); - assert(obj->is_oop() || obj->mark() == NULL, - "expected an oop, possibly with mark word displaced"); - HeapWord* addr = (HeapWord*)obj; - if (_g1h->is_in_g1_reserved(addr)) { - _cm->grayRoot(obj); - } - } - if (_do_barrier) { - assert(!_g1h->is_in_g1_reserved(p), - "Should be called on external roots"); - do_barrier(p); - } - } -}; void ConcurrentMark::checkpointRootsInitialPost() { G1CollectedHeap* g1h = G1CollectedHeap::heap(); @@ -868,50 +835,6 @@ // during it. No need to call it here. } -// Checkpoint the roots into this generation from outside -// this generation. [Note this initial checkpoint need only -// be approximate -- we'll do a catch up phase subsequently.] -void ConcurrentMark::checkpointRootsInitial() { - assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped"); - G1CollectedHeap* g1h = G1CollectedHeap::heap(); - - double start = os::elapsedTime(); - - G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy(); - g1p->record_concurrent_mark_init_start(); - checkpointRootsInitialPre(); - - // YSR: when concurrent precleaning is in place, we'll - // need to clear the cached card table here - - ResourceMark rm; - HandleMark hm; - - g1h->ensure_parsability(false); - g1h->perm_gen()->save_marks(); - - CMMarkRootsClosure notOlder(this, g1h, false); - CMMarkRootsClosure older(this, g1h, true); - - g1h->set_marking_started(); - g1h->rem_set()->prepare_for_younger_refs_iterate(false); - - g1h->process_strong_roots(true, // activate StrongRootsScope - false, // fake perm gen collection - SharedHeap::SO_AllClasses, - ¬Older, // Regular roots - NULL, // do not visit active blobs - &older // Perm Gen Roots - ); - checkpointRootsInitialPost(); - - // Statistics. - double end = os::elapsedTime(); - _init_times.add((end - start) * 1000.0); - - g1p->record_concurrent_mark_init_end(); -} - /* * Notice that in the next two methods, we actually leave the STS * during the barrier sync and join it immediately afterwards. If we
--- a/src/share/vm/gc_implementation/g1/concurrentMark.hpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.hpp Tue Sep 06 21:29:34 2011 -0700 @@ -756,9 +756,6 @@ // Clear the next marking bitmap (will be called concurrently). void clearNextBitmap(); - // main CMS steps and related support - void checkpointRootsInitial(); - // These two do the work that needs to be done before and after the // initial root checkpoint. Since this checkpoint can be done at two // different points (i.e. an explicit pause or piggy-backed on a
--- a/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp Tue Sep 06 21:29:34 2011 -0700 @@ -50,19 +50,6 @@ create_and_start(); } -class CMCheckpointRootsInitialClosure: public VoidClosure { - - ConcurrentMark* _cm; -public: - - CMCheckpointRootsInitialClosure(ConcurrentMark* cm) : - _cm(cm) {} - - void do_void(){ - _cm->checkpointRootsInitial(); - } -}; - class CMCheckpointRootsFinalClosure: public VoidClosure { ConcurrentMark* _cm; @@ -116,27 +103,6 @@ gclog_or_tty->print_cr("[GC concurrent-mark-start]"); } - if (!g1_policy->in_young_gc_mode()) { - // this ensures the flag is not set if we bail out of the marking - // cycle; normally the flag is cleared immediately after cleanup - g1h->set_marking_complete(); - - if (g1_policy->adaptive_young_list_length()) { - double now = os::elapsedTime(); - double init_prediction_ms = g1_policy->predict_init_time_ms(); - jlong sleep_time_ms = mmu_tracker->when_ms(now, init_prediction_ms); - os::sleep(current_thread, sleep_time_ms, false); - } - - // We don't have to skip here if we've been asked to restart, because - // in the worst case we just enqueue a new VM operation to start a - // marking. Note that the init operation resets has_aborted() - CMCheckpointRootsInitialClosure init_cl(_cm); - strcpy(verbose_str, "GC initial-mark"); - VM_CGC_Operation op(&init_cl, verbose_str); - VMThread::execute(&op); - } - int iter = 0; do { iter++;
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Tue Sep 06 21:29:34 2011 -0700 @@ -1227,6 +1227,7 @@ /* option */ VerifyOption_G1UsePrevMarking); } + pre_full_gc_dump(); COMPILER2_PRESENT(DerivedPointerTable::clear()); @@ -1263,10 +1264,8 @@ g1_policy()->clear_incremental_cset(); g1_policy()->stop_incremental_cset_building(); - if (g1_policy()->in_young_gc_mode()) { - empty_young_list(); - g1_policy()->set_full_young_gcs(true); - } + empty_young_list(); + g1_policy()->set_full_young_gcs(true); // See the comment in G1CollectedHeap::ref_processing_init() about // how reference processing currently works in G1. @@ -1387,13 +1386,11 @@ || (G1DeferredRSUpdate && (dirty_card_queue_set().completed_buffers_num() == 0)), "Should not be any"); } - if (g1_policy()->in_young_gc_mode()) { - _young_list->reset_sampled_info(); - // At this point there should be no regions in the - // entire heap tagged as young. - assert( check_young_list_empty(true /* check_heap */), - "young list should be empty at this point"); - } + _young_list->reset_sampled_info(); + // At this point there should be no regions in the + // entire heap tagged as young. + assert( check_young_list_empty(true /* check_heap */), + "young list should be empty at this point"); // Update the number of full collections that have been completed. increment_full_collections_completed(false /* concurrent */); @@ -1405,6 +1402,7 @@ Universe::print_heap_after_gc(); } g1mm()->update_counters(); + post_full_gc_dump(); return true; } @@ -3161,12 +3159,6 @@ } } -void G1CollectedHeap::do_sync_mark() { - _cm->checkpointRootsInitial(); - _cm->markFromRoots(); - _cm->checkpointRootsFinal(false); -} - // <NEW PREDICTION> double G1CollectedHeap::predict_region_elapsed_time_ms(HeapRegion *hr, @@ -3317,11 +3309,10 @@ char verbose_str[128]; sprintf(verbose_str, "GC pause "); - if (g1_policy()->in_young_gc_mode()) { - if (g1_policy()->full_young_gcs()) - strcat(verbose_str, "(young)"); - else - strcat(verbose_str, "(partial)"); + if (g1_policy()->full_young_gcs()) { + strcat(verbose_str, "(young)"); + } else { + strcat(verbose_str, "(partial)"); } if (g1_policy()->during_initial_mark_pause()) { strcat(verbose_str, " (initial-mark)"); @@ -3350,10 +3341,8 @@ append_secondary_free_list_if_not_empty_with_lock(); } - if (g1_policy()->in_young_gc_mode()) { - assert(check_young_list_well_formed(), - "young list should be well formed"); - } + assert(check_young_list_well_formed(), + "young list should be well formed"); { // Call to jvmpi::post_class_unload_events must occur outside of active GC IsGCActiveMark x; @@ -3494,27 +3483,25 @@ // evacuation pause. clear_cset_fast_test(); - if (g1_policy()->in_young_gc_mode()) { - _young_list->reset_sampled_info(); - - // Don't check the whole heap at this point as the - // GC alloc regions from this pause have been tagged - // as survivors and moved on to the survivor list. - // Survivor regions will fail the !is_young() check. - assert(check_young_list_empty(false /* check_heap */), - "young list should be empty"); + _young_list->reset_sampled_info(); + + // Don't check the whole heap at this point as the + // GC alloc regions from this pause have been tagged + // as survivors and moved on to the survivor list. + // Survivor regions will fail the !is_young() check. + assert(check_young_list_empty(false /* check_heap */), + "young list should be empty"); #if YOUNG_LIST_VERBOSE - gclog_or_tty->print_cr("Before recording survivors.\nYoung List:"); - _young_list->print(); + gclog_or_tty->print_cr("Before recording survivors.\nYoung List:"); + _young_list->print(); #endif // YOUNG_LIST_VERBOSE - g1_policy()->record_survivor_regions(_young_list->survivor_length(), - _young_list->first_survivor_region(), - _young_list->last_survivor_region()); - - _young_list->reset_auxilary_lists(); - } + g1_policy()->record_survivor_regions(_young_list->survivor_length(), + _young_list->first_survivor_region(), + _young_list->last_survivor_region()); + + _young_list->reset_auxilary_lists(); if (evacuation_failed()) { _summary_bytes_used = recalculate_used(); @@ -3524,8 +3511,7 @@ _summary_bytes_used += g1_policy()->bytes_copied_during_gc(); } - if (g1_policy()->in_young_gc_mode() && - g1_policy()->during_initial_mark_pause()) { + if (g1_policy()->during_initial_mark_pause()) { concurrent_mark()->checkpointRootsInitialPost(); set_marking_started(); // CAUTION: after the doConcurrentMark() call below, @@ -5091,7 +5077,6 @@ void G1CollectedHeap::empty_young_list() { assert(heap_lock_held_for_gc(), "the heap lock should already be held by or for this thread"); - assert(g1_policy()->in_young_gc_mode(), "should be in young GC mode"); _young_list->empty_list(); }
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Tue Sep 06 21:29:34 2011 -0700 @@ -1263,16 +1263,10 @@ // in the young gen: for the SATB pre-barrier, there is no // pre-value that needs to be remembered; for the remembered-set // update logging post-barrier, we don't maintain remembered set - // information for young gen objects. Note that non-generational - // G1 does not have any "young" objects, should not elide - // the rs logging barrier and so should always answer false below. - // However, non-generational G1 (-XX:-G1Gen) appears to have - // bit-rotted so was not tested below. + // information for young gen objects. virtual bool can_elide_initializing_store_barrier(oop new_obj) { // Re 6920090, 6920109 above. assert(ReduceInitialCardMarksForG1, "Else cannot be here"); - assert(G1Gen || !is_in_young(new_obj), - "Non-generational G1 should never return true below"); return is_in_young(new_obj); } @@ -1389,9 +1383,6 @@ // bitmap off to the side. void doConcurrentMark(); - // Do a full concurrent marking, synchronously. - void do_sync_mark(); - bool isMarkedPrev(oop obj) const; bool isMarkedNext(oop obj) const;
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Tue Sep 06 21:29:34 2011 -0700 @@ -170,7 +170,6 @@ _cur_aux_times_ms(new double[_aux_num]), _cur_aux_times_set(new bool[_aux_num]), - _concurrent_mark_init_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), _concurrent_mark_remark_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), _concurrent_mark_cleanup_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), @@ -201,7 +200,6 @@ // </NEW PREDICTION> - _in_young_gc_mode(false), _full_young_gcs(true), _full_young_pause_num(0), _partial_young_pause_num(0), @@ -400,15 +398,12 @@ _sigma = (double) G1ConfidencePercent / 100.0; // start conservatively (around 50ms is about right) - _concurrent_mark_init_times_ms->add(0.05); _concurrent_mark_remark_times_ms->add(0.05); _concurrent_mark_cleanup_times_ms->add(0.20); _tenuring_threshold = MaxTenuringThreshold; - - // if G1FixedSurvivorSpaceSize is 0 which means the size is not - // fixed, then _max_survivor_regions will be calculated at - // calculate_young_list_target_length during initialization - _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes; + // _max_survivor_regions will be calculated by + // calculate_young_list_target_length() during initialization. + _max_survivor_regions = 0; assert(GCTimeRatio > 0, "we should have set it to a default value set_g1_gc_flags() " @@ -468,27 +463,20 @@ initialize_gc_policy_counters(); - if (G1Gen) { - _in_young_gc_mode = true; - - G1YoungGenSizer sizer; - size_t initial_region_num = sizer.initial_young_region_num(); - - if (UseAdaptiveSizePolicy) { - set_adaptive_young_list_length(true); - _young_list_fixed_length = 0; - } else { - set_adaptive_young_list_length(false); - _young_list_fixed_length = initial_region_num; - } - _free_regions_at_end_of_collection = _g1->free_regions(); - calculate_young_list_min_length(); - guarantee( _young_list_min_length == 0, "invariant, not enough info" ); - calculate_young_list_target_length(); + G1YoungGenSizer sizer; + size_t initial_region_num = sizer.initial_young_region_num(); + + if (UseAdaptiveSizePolicy) { + set_adaptive_young_list_length(true); + _young_list_fixed_length = 0; } else { - _young_list_fixed_length = 0; - _in_young_gc_mode = false; + set_adaptive_young_list_length(false); + _young_list_fixed_length = initial_region_num; } + _free_regions_at_end_of_collection = _g1->free_regions(); + calculate_young_list_min_length(); + guarantee( _young_list_min_length == 0, "invariant, not enough info" ); + calculate_young_list_target_length(); // We may immediately start allocating regions and placing them on the // collection set list. Initialize the per-collection set info @@ -498,7 +486,7 @@ // Create the jstat counters for the policy. void G1CollectorPolicy::initialize_gc_policy_counters() { - _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 2 + G1Gen); + _gc_policy_counters = new GCPolicyCounters("GarbageFirst", 1, 3); } void G1CollectorPolicy::calculate_young_list_min_length() { @@ -868,8 +856,7 @@ if (PrintGCDetails) { gclog_or_tty->stamp(PrintGCTimeStamps); gclog_or_tty->print("[GC pause"); - if (in_young_gc_mode()) - gclog_or_tty->print(" (%s)", full_young_gcs() ? "young" : "partial"); + gclog_or_tty->print(" (%s)", full_young_gcs() ? "young" : "partial"); } assert(_g1->used() == _g1->recalculate_used(), @@ -921,8 +908,7 @@ _satb_drain_time_set = false; _last_satb_drain_processed_buffers = -1; - if (in_young_gc_mode()) - _last_young_gc_full = false; + _last_young_gc_full = false; // do that for any other surv rate groups _short_lived_surv_rate_group->stop_adding_regions(); @@ -935,12 +921,7 @@ _mark_closure_time_ms = mark_closure_time_ms; } -void G1CollectorPolicy::record_concurrent_mark_init_start() { - _mark_init_start_sec = os::elapsedTime(); - guarantee(!in_young_gc_mode(), "should not do be here in young GC mode"); -} - -void G1CollectorPolicy::record_concurrent_mark_init_end_pre(double +void G1CollectorPolicy::record_concurrent_mark_init_end(double mark_init_elapsed_time_ms) { _during_marking = true; assert(!initiate_conc_mark_if_possible(), "we should have cleared it by now"); @@ -948,15 +929,6 @@ _cur_mark_stop_world_time_ms = mark_init_elapsed_time_ms; } -void G1CollectorPolicy::record_concurrent_mark_init_end() { - double end_time_sec = os::elapsedTime(); - double elapsed_time_ms = (end_time_sec - _mark_init_start_sec) * 1000.0; - _concurrent_mark_init_times_ms->add(elapsed_time_ms); - record_concurrent_mark_init_end_pre(elapsed_time_ms); - - _mmu_tracker->add_pause(_mark_init_start_sec, end_time_sec, true); -} - void G1CollectorPolicy::record_concurrent_mark_remark_start() { _mark_remark_start_sec = os::elapsedTime(); _during_marking = false; @@ -1019,13 +991,11 @@ void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() { - if (in_young_gc_mode()) { - _should_revert_to_full_young_gcs = false; - _last_full_young_gc = true; - _in_marking_window = false; - if (adaptive_young_list_length()) - calculate_young_list_target_length(); - } + _should_revert_to_full_young_gcs = false; + _last_full_young_gc = true; + _in_marking_window = false; + if (adaptive_young_list_length()) + calculate_young_list_target_length(); } void G1CollectorPolicy::record_concurrent_pause() { @@ -1174,31 +1144,29 @@ } #endif // PRODUCT - if (in_young_gc_mode()) { - last_pause_included_initial_mark = during_initial_mark_pause(); - if (last_pause_included_initial_mark) - record_concurrent_mark_init_end_pre(0.0); - - size_t min_used_targ = - (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; - - - if (!_g1->mark_in_progress() && !_last_full_young_gc) { - assert(!last_pause_included_initial_mark, "invariant"); - if (cur_used_bytes > min_used_targ && - cur_used_bytes > _prev_collection_pause_used_at_end_bytes) { + last_pause_included_initial_mark = during_initial_mark_pause(); + if (last_pause_included_initial_mark) + record_concurrent_mark_init_end(0.0); + + size_t min_used_targ = + (_g1->capacity() / 100) * InitiatingHeapOccupancyPercent; + + + if (!_g1->mark_in_progress() && !_last_full_young_gc) { + assert(!last_pause_included_initial_mark, "invariant"); + if (cur_used_bytes > min_used_targ && + cur_used_bytes > _prev_collection_pause_used_at_end_bytes) { assert(!during_initial_mark_pause(), "we should not see this here"); // Note: this might have already been set, if during the last // pause we decided to start a cycle but at the beginning of // this pause we decided to postpone it. That's OK. set_initiate_conc_mark_if_possible(); - } } - - _prev_collection_pause_used_at_end_bytes = cur_used_bytes; } + _prev_collection_pause_used_at_end_bytes = cur_used_bytes; + _mmu_tracker->add_pause(end_time_sec - elapsed_ms/1000.0, end_time_sec, false); @@ -1468,24 +1436,23 @@ new_in_marking_window_im = true; } - if (in_young_gc_mode()) { - if (_last_full_young_gc) { - set_full_young_gcs(false); - _last_full_young_gc = false; + if (_last_full_young_gc) { + set_full_young_gcs(false); + _last_full_young_gc = false; + } + + if ( !_last_young_gc_full ) { + if ( _should_revert_to_full_young_gcs || + _known_garbage_ratio < 0.05 || + (adaptive_young_list_length() && + (get_gc_eff_factor() * cur_efficiency < predict_young_gc_eff())) ) { + set_full_young_gcs(true); } - - if ( !_last_young_gc_full ) { - if ( _should_revert_to_full_young_gcs || - _known_garbage_ratio < 0.05 || - (adaptive_young_list_length() && - (get_gc_eff_factor() * cur_efficiency < predict_young_gc_eff())) ) { - set_full_young_gcs(true); - } - } - _should_revert_to_full_young_gcs = false; - - if (_last_young_gc_full && !_during_marking) - _young_gc_eff_seq->add(cur_efficiency); + } + _should_revert_to_full_young_gcs = false; + + if (_last_young_gc_full && !_during_marking) { + _young_gc_eff_seq->add(cur_efficiency); } _short_lived_surv_rate_group->start_adding_regions(); @@ -1910,18 +1877,8 @@ // I don't think we need to do this when in young GC mode since // marking will be initiated next time we hit the soft limit anyway... if (predicted_time_ms > _expensive_region_limit_ms) { - if (!in_young_gc_mode()) { - set_full_young_gcs(true); - // We might want to do something different here. However, - // right now we don't support the non-generational G1 mode - // (and in fact we are planning to remove the associated code, - // see CR 6814390). So, let's leave it as is and this will be - // removed some time in the future - ShouldNotReachHere(); - set_during_initial_mark_pause(); - } else - // no point in doing another partial one - _should_revert_to_full_young_gcs = true; + // no point in doing another partial one + _should_revert_to_full_young_gcs = true; } } @@ -2331,18 +2288,9 @@ // Calculates survivor space parameters. void G1CollectorPolicy::calculate_survivors_policy() { - if (G1FixedSurvivorSpaceSize == 0) { - _max_survivor_regions = _young_list_target_length / SurvivorRatio; - } else { - _max_survivor_regions = G1FixedSurvivorSpaceSize / HeapRegion::GrainBytes; - } - - if (G1FixedTenuringThreshold) { - _tenuring_threshold = MaxTenuringThreshold; - } else { - _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( + _max_survivor_regions = _young_list_target_length / SurvivorRatio; + _tenuring_threshold = _survivors_age_table.compute_tenuring_threshold( HeapRegion::GrainWords * _max_survivor_regions); - } } #ifndef PRODUCT @@ -2617,9 +2565,7 @@ _inc_cset_size = 0; _inc_cset_bytes_used_before = 0; - if (in_young_gc_mode()) { - _inc_cset_young_index = 0; - } + _inc_cset_young_index = 0; _inc_cset_max_finger = 0; _inc_cset_recorded_young_bytes = 0; @@ -2848,86 +2794,77 @@ max_live_bytes = max_live_bytes + expansion_bytes; HeapRegion* hr; - if (in_young_gc_mode()) { - double young_start_time_sec = os::elapsedTime(); - - if (G1PolicyVerbose > 0) { - gclog_or_tty->print_cr("Adding %d young regions to the CSet", - _g1->young_list()->length()); - } - - _young_cset_length = 0; - _last_young_gc_full = full_young_gcs() ? true : false; - - if (_last_young_gc_full) - ++_full_young_pause_num; - else - ++_partial_young_pause_num; - - // The young list is laid with the survivor regions from the previous - // pause are appended to the RHS of the young list, i.e. - // [Newly Young Regions ++ Survivors from last pause]. - - hr = _g1->young_list()->first_survivor_region(); - while (hr != NULL) { - assert(hr->is_survivor(), "badly formed young list"); - hr->set_young(); - hr = hr->get_next_young_region(); - } - - // Clear the fields that point to the survivor list - they are - // all young now. - _g1->young_list()->clear_survivors(); - - if (_g1->mark_in_progress()) - _g1->concurrent_mark()->register_collection_set_finger(_inc_cset_max_finger); - - _young_cset_length = _inc_cset_young_index; - _collection_set = _inc_cset_head; - _collection_set_size = _inc_cset_size; - _collection_set_bytes_used_before = _inc_cset_bytes_used_before; - - // For young regions in the collection set, we assume the worst - // case of complete survival - max_live_bytes -= _inc_cset_size * HeapRegion::GrainBytes; - - time_remaining_ms -= _inc_cset_predicted_elapsed_time_ms; - predicted_pause_time_ms += _inc_cset_predicted_elapsed_time_ms; - - // The number of recorded young regions is the incremental - // collection set's current size - set_recorded_young_regions(_inc_cset_size); - set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths); - set_recorded_young_bytes(_inc_cset_recorded_young_bytes); + double young_start_time_sec = os::elapsedTime(); + + if (G1PolicyVerbose > 0) { + gclog_or_tty->print_cr("Adding %d young regions to the CSet", + _g1->young_list()->length()); + } + + _young_cset_length = 0; + _last_young_gc_full = full_young_gcs() ? true : false; + + if (_last_young_gc_full) + ++_full_young_pause_num; + else + ++_partial_young_pause_num; + + // The young list is laid with the survivor regions from the previous + // pause are appended to the RHS of the young list, i.e. + // [Newly Young Regions ++ Survivors from last pause]. + + hr = _g1->young_list()->first_survivor_region(); + while (hr != NULL) { + assert(hr->is_survivor(), "badly formed young list"); + hr->set_young(); + hr = hr->get_next_young_region(); + } + + // Clear the fields that point to the survivor list - they are + // all young now. + _g1->young_list()->clear_survivors(); + + if (_g1->mark_in_progress()) + _g1->concurrent_mark()->register_collection_set_finger(_inc_cset_max_finger); + + _young_cset_length = _inc_cset_young_index; + _collection_set = _inc_cset_head; + _collection_set_size = _inc_cset_size; + _collection_set_bytes_used_before = _inc_cset_bytes_used_before; + + // For young regions in the collection set, we assume the worst + // case of complete survival + max_live_bytes -= _inc_cset_size * HeapRegion::GrainBytes; + + time_remaining_ms -= _inc_cset_predicted_elapsed_time_ms; + predicted_pause_time_ms += _inc_cset_predicted_elapsed_time_ms; + + // The number of recorded young regions is the incremental + // collection set's current size + set_recorded_young_regions(_inc_cset_size); + set_recorded_rs_lengths(_inc_cset_recorded_rs_lengths); + set_recorded_young_bytes(_inc_cset_recorded_young_bytes); #if PREDICTIONS_VERBOSE - set_predicted_bytes_to_copy(_inc_cset_predicted_bytes_to_copy); + set_predicted_bytes_to_copy(_inc_cset_predicted_bytes_to_copy); #endif // PREDICTIONS_VERBOSE - if (G1PolicyVerbose > 0) { - gclog_or_tty->print_cr(" Added " PTR_FORMAT " Young Regions to CS.", - _inc_cset_size); - gclog_or_tty->print_cr(" (" SIZE_FORMAT " KB left in heap.)", - max_live_bytes/K); - } - - assert(_inc_cset_size == _g1->young_list()->length(), "Invariant"); - - double young_end_time_sec = os::elapsedTime(); - _recorded_young_cset_choice_time_ms = - (young_end_time_sec - young_start_time_sec) * 1000.0; - - // We are doing young collections so reset this. - non_young_start_time_sec = young_end_time_sec; - - // Note we can use either _collection_set_size or - // _young_cset_length here - if (_collection_set_size > 0 && _last_young_gc_full) { - // don't bother adding more regions... - goto choose_collection_set_end; - } + if (G1PolicyVerbose > 0) { + gclog_or_tty->print_cr(" Added " PTR_FORMAT " Young Regions to CS.", + _inc_cset_size); + gclog_or_tty->print_cr(" (" SIZE_FORMAT " KB left in heap.)", + max_live_bytes/K); } - if (!in_young_gc_mode() || !full_young_gcs()) { + assert(_inc_cset_size == _g1->young_list()->length(), "Invariant"); + + double young_end_time_sec = os::elapsedTime(); + _recorded_young_cset_choice_time_ms = + (young_end_time_sec - young_start_time_sec) * 1000.0; + + // We are doing young collections so reset this. + non_young_start_time_sec = young_end_time_sec; + + if (!full_young_gcs()) { bool should_continue = true; NumberSeq seq; double avg_prediction = 100000000000000000.0; // something very large @@ -2960,7 +2897,6 @@ _should_revert_to_full_young_gcs = true; } -choose_collection_set_end: stop_incremental_cset_building(); count_CS_bytes_used();
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Tue Sep 06 21:29:34 2011 -0700 @@ -141,7 +141,6 @@ TruncatedSeq* _recent_rs_sizes; - TruncatedSeq* _concurrent_mark_init_times_ms; TruncatedSeq* _concurrent_mark_remark_times_ms; TruncatedSeq* _concurrent_mark_cleanup_times_ms; @@ -178,9 +177,6 @@ double* _par_last_gc_worker_end_times_ms; double* _par_last_gc_worker_times_ms; - // indicates that we are in young GC mode - bool _in_young_gc_mode; - // indicates whether we are in full young or partially young GC mode bool _full_young_gcs; @@ -527,10 +523,6 @@ return _mmu_tracker->max_gc_time() * 1000.0; } - double predict_init_time_ms() { - return get_new_prediction(_concurrent_mark_init_times_ms); - } - double predict_remark_time_ms() { return get_new_prediction(_concurrent_mark_remark_times_ms); } @@ -776,7 +768,6 @@ // This set of variables tracks the collector efficiency, in order to // determine whether we should initiate a new marking. double _cur_mark_stop_world_time_ms; - double _mark_init_start_sec; double _mark_remark_start_sec; double _mark_cleanup_start_sec; double _mark_closure_time_ms; @@ -849,9 +840,7 @@ size_t start_used); // Must currently be called while the world is stopped. - virtual void record_concurrent_mark_init_start(); - virtual void record_concurrent_mark_init_end(); - void record_concurrent_mark_init_end_pre(double + void record_concurrent_mark_init_end(double mark_init_elapsed_time_ms); void record_mark_closure_time(double mark_closure_time_ms); @@ -1101,30 +1090,17 @@ bool is_young_list_full() { size_t young_list_length = _g1->young_list()->length(); size_t young_list_target_length = _young_list_target_length; - if (G1FixedEdenSize) { - young_list_target_length -= _max_survivor_regions; - } return young_list_length >= young_list_target_length; } bool can_expand_young_list() { size_t young_list_length = _g1->young_list()->length(); size_t young_list_max_length = _young_list_max_length; - if (G1FixedEdenSize) { - young_list_max_length -= _max_survivor_regions; - } return young_list_length < young_list_max_length; } void update_region_num(bool young); - bool in_young_gc_mode() { - return _in_young_gc_mode; - } - void set_in_young_gc_mode(bool in_young_gc_mode) { - _in_young_gc_mode = in_young_gc_mode; - } - bool full_young_gcs() { return _full_young_gcs; }
--- a/src/share/vm/gc_implementation/g1/g1_globals.hpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/vm/gc_implementation/g1/g1_globals.hpp Tue Sep 06 21:29:34 2011 -0700 @@ -39,8 +39,6 @@ develop(intx, G1MarkingOverheadPercent, 0, \ "Overhead of concurrent marking") \ \ - develop(bool, G1Gen, true, \ - "If true, it will enable the generational G1") \ \ develop(intx, G1PolicyVerbose, 0, \ "The verbosity level on G1 policy decisions") \ @@ -251,16 +249,6 @@ "When set, G1 will fail when it encounters an FP 'error', " \ "so as to allow debugging") \ \ - develop(bool, G1FixedTenuringThreshold, false, \ - "When set, G1 will not adjust the tenuring threshold") \ - \ - develop(bool, G1FixedEdenSize, false, \ - "When set, G1 will not allocate unused survivor space regions") \ - \ - develop(uintx, G1FixedSurvivorSpaceSize, 0, \ - "If non-0 is the size of the G1 survivor space, " \ - "otherwise SurvivorRatio is used to determine the size") \ - \ product(uintx, G1HeapRegionSize, 0, \ "Size of the G1 regions.") \ \
--- a/src/share/vm/gc_interface/collectedHeap.cpp Tue Aug 23 21:17:02 2011 -0700 +++ b/src/share/vm/gc_interface/collectedHeap.cpp Tue Sep 06 21:29:34 2011 -0700 @@ -404,13 +404,13 @@ void CollectedHeap::pre_full_gc_dump() { if (HeapDumpBeforeFullGC) { - TraceTime tt("Heap Dump: ", PrintGCDetails, false, gclog_or_tty); + TraceTime tt("Heap Dump (before full gc): ", PrintGCDetails, false, gclog_or_tty); // We are doing a "major" collection and a heap dump before // major collection has been requested. HeapDumper::dump_heap(); } if (PrintClassHistogramBeforeFullGC) { - TraceTime tt("Class Histogram: ", PrintGCDetails, true, gclog_or_tty); + TraceTime tt("Class Histogram (before full gc): ", PrintGCDetails, true, gclog_or_tty); VM_GC_HeapInspection inspector(gclog_or_tty, false /* ! full gc */, false /* ! prologue */); inspector.doit(); } @@ -418,11 +418,11 @@ void CollectedHeap::post_full_gc_dump() { if (HeapDumpAfterFullGC) { - TraceTime tt("Heap Dump", PrintGCDetails, false, gclog_or_tty); + TraceTime tt("Heap Dump (after full gc): ", PrintGCDetails, false, gclog_or_tty); HeapDumper::dump_heap(); } if (PrintClassHistogramAfterFullGC) { - TraceTime tt("Class Histogram", PrintGCDetails, true, gclog_or_tty); + TraceTime tt("Class Histogram (after full gc): ", PrintGCDetails, true, gclog_or_tty); VM_GC_HeapInspection inspector(gclog_or_tty, false /* ! full gc */, false /* ! prologue */); inspector.doit(); }
--- a/test/compiler/5091921/Test7005594.sh Tue Aug 23 21:17:02 2011 -0700 +++ b/test/compiler/5091921/Test7005594.sh Tue Sep 06 21:29:34 2011 -0700 @@ -43,6 +43,45 @@ echo "TESTCLASSES=${TESTCLASSES}" echo "CLASSPATH=${CLASSPATH}" +# Amount of physical memory in megabytes +MEM=0 +if [ -f "/proc/meminfo" ]; then + # Linux, Windows/Cygwin + MEM=`cat /proc/meminfo |grep ^MemTotal: | awk '{print $2}'` + MEM="$(($MEM / 1024))" +elif [ -x "/usr/sbin/prtconf" ]; then + # Solaris + MEM=`/usr/sbin/prtconf | grep "^Memory size" | awk '{print $3}'` +elif [ -x "/usr/sbin/system_profiler" ]; then + # MacOS + MEMo=`/usr/sbin/system_profiler SPHardwareDataType | grep Memory:` + MEM=`echo "$MEMo" | awk '{print $2}'` + MEMu=`echo "$MEMo" | awk '{print $3}'` + case $MEMu in + GB) + MEM="$(($MEM * 1024))" + ;; + MB) + ;; + *) + echo "Unknown memory unit in system_profile output: $MEMu" + ;; + esac +elif [ -n "$ROOTDIR" -a -x "$ROOTDIR/mksnt/sysinf" ]; then + # Windows/MKS + MEM=`"$ROOTDIR/mksnt/sysinf" memory -v | grep "Total Physical Memory: " | sed 's/Total Physical Memory: *//g'` + MEM="$(($machine_memory / 1024))" +else + echo "Unable to determine amount of physical memory on the machine" +fi + +if [ $MEM -lt 2000 ]; then + echo "Test skipped due to low (or unknown) memory on the system: $MEM Mb" + exit 0 +fi + +echo "MEMORY=$MEM Mb" + set -x cp ${TESTSRC}/Test7005594.java . @@ -50,7 +89,7 @@ ${TESTJAVA}/bin/javac -d . Test7005594.java -${TESTJAVA}/bin/java ${TESTVMOPTS} -Xms1600m -Xcomp -XX:CompileOnly=Test7005594.test Test7005594 > test.out 2>&1 +${TESTJAVA}/bin/java ${TESTVMOPTS} -Xms1600m -XX:+IgnoreUnrecognizedVMOptions -XX:-ZapUnusedHeapArea -Xcomp -XX:CompileOnly=Test7005594.test Test7005594 > test.out 2>&1 result=$?