graal-jvmci-8: src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 4013:074f0252cc13

7088680: G1: Cleanup in the G1CollectorPolicy class Summary: Removed unused fields and methods, removed the G1CollectoryPolicy_BestRegionsFirst class and folded its functionality into the G1CollectorPolicy class. Reviewed-by: ysr, brutisso, jcoomes

author	tonyp
date	Fri, 14 Oct 2011 11:12:24 -0400
parents	65a8ff39a6da
children	c6a6e936dc68

comparison

equal deleted inserted replaced

-:ec4b032a4977
+:074f0252cc13
 _recent_CS_bytes_used_before(new TruncatedSeq(NumPrevPausesForHeuristics)),
 _recent_CS_bytes_surviving(new TruncatedSeq(NumPrevPausesForHeuristics)),
 _recent_avg_pause_time_ratio(0.0),
-_num_markings(0),
-_n_marks(0),
-_n_pauses_at_mark_end(0),
 _all_full_gc_times_ms(new NumberSeq()),
 // G1PausesBtwnConcMark defaults to -1
 // so the hack is to do the cast  QQQ FIXME
 _pauses_btwn_concurrent_mark((size_t)G1PausesBtwnConcMark),
-_n_marks_since_last_pause(0),
 _initiate_conc_mark_if_possible(false),
 _during_initial_mark_pause(false),
 _should_revert_to_full_young_gcs(false),
 _last_full_young_gc(false),
 // This will be set when the heap is expanded
 // for the first time during initialization.
 _reserve_regions = 0;
 initialize_all();
+_collectionSetChooser = new CollectionSetChooser();
 }
 // Increment "i", mod "len"
 static void inc_mod(int& i, int len) {
 i++; if (i == len) i = 0;
 _free_regions_at_end_of_collection = _g1->free_regions();
 // Reset survivors SurvRateGroup.
 _survivor_surv_rate_group->reset();
 update_young_list_target_length();
+_collectionSetChooser->updateAfterFullCollection();
 }
 void G1CollectorPolicy::record_stop_world_start() {
 _stop_world_start = os::elapsedTime();
 }
 void G1CollectorPolicy::record_concurrent_mark_cleanup_start() {
 _mark_cleanup_start_sec = os::elapsedTime();
 }
-void
+void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() {
-G1CollectorPolicy::record_concurrent_mark_cleanup_end(size_t freed_bytes,
-size_t max_live_bytes) {
-record_concurrent_mark_cleanup_end_work1(freed_bytes, max_live_bytes);
-record_concurrent_mark_cleanup_end_work2();
-}
-void
-G1CollectorPolicy::
-record_concurrent_mark_cleanup_end_work1(size_t freed_bytes,
-size_t max_live_bytes) {
-if (_n_marks < 2) {
-_n_marks++;
-}
-}
-// The important thing about this is that it includes "os::elapsedTime".
-void G1CollectorPolicy::record_concurrent_mark_cleanup_end_work2() {
-double end_time_sec = os::elapsedTime();
-double elapsed_time_ms = (end_time_sec - _mark_cleanup_start_sec)*1000.0;
-_concurrent_mark_cleanup_times_ms->add(elapsed_time_ms);
-_cur_mark_stop_world_time_ms += elapsed_time_ms;
-_prev_collection_pause_end_ms += elapsed_time_ms;
-_mmu_tracker->add_pause(_mark_cleanup_start_sec, end_time_sec, true);
-_num_markings++;
-_n_pauses_at_mark_end = _n_pauses;
-_n_marks_since_last_pause++;
-}
-void
-G1CollectorPolicy::record_concurrent_mark_cleanup_completed() {
 _should_revert_to_full_young_gcs = false;
 _last_full_young_gc = true;
 _in_marking_window = false;
 }
 if (update_stats) {
 summary->record_total_time_ms(elapsed_ms);
 summary->record_other_time_ms(other_time_ms);
 }
 for (int i = 0; i < _aux_num; ++i)
-if (_cur_aux_times_set[i])
+if (_cur_aux_times_set[i]) {
 _all_aux_times_ms[i].add(_cur_aux_times_ms[i]);
+}
-// Reset marks-between-pauses counter.
-_n_marks_since_last_pause = 0;
 // Update the efficiency-since-mark vars.
 double proc_ms = elapsed_ms * (double) _parallel_gc_threads;
 if (elapsed_ms < MIN_TIMER_GRANULARITY) {
 // This usually happens due to the timer not having the required
 // Note that _mmu_tracker->max_gc_time() returns the time in seconds.
 double update_rs_time_goal_ms = _mmu_tracker->max_gc_time() * MILLIUNITS * G1RSetUpdatingPauseTimePercent / 100.0;
 adjust_concurrent_refinement(update_rs_time, update_rs_processed_buffers, update_rs_time_goal_ms);
 // </NEW PREDICTION>
+assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end.");
 }
 #define EXT_SIZE_FORMAT "%d%s"
 #define EXT_SIZE_PARAMS(bytes)                                  \
 byte_size_in_proper_unit((bytes)),                            \
 return expand_bytes;
 } else {
 return 0;
 }
-}
-void G1CollectorPolicy::note_start_of_mark_thread() {
-_mark_thread_startup_sec = os::elapsedTime();
 }
 class CountCSClosure: public HeapRegionClosure {
 G1CollectorPolicy* _g1_policy;
 public:
 }
 return false;
 }
 };
-bool G1CollectorPolicy_BestRegionsFirst::assertMarkedBytesDataOK() {
+bool G1CollectorPolicy::assertMarkedBytesDataOK() {
 HRSortIndexIsOKClosure cl(_collectionSetChooser);
 _g1->heap_region_iterate(&cl);
 return true;
 }
 #endif
 ergo_format_reason("concurrent cycle already in progress"));
 }
 }
 }
-void
-G1CollectorPolicy_BestRegionsFirst::
-record_collection_pause_start(double start_time_sec, size_t start_used) {
-G1CollectorPolicy::record_collection_pause_start(start_time_sec, start_used);
-}
 class KnownGarbageClosure: public HeapRegionClosure {
 CollectionSetChooser* _hrSorted;
 public:
 KnownGarbageClosure(CollectionSetChooser* hrSorted) :
 }
 }
 };
 void
-G1CollectorPolicy_BestRegionsFirst::
+G1CollectorPolicy::record_concurrent_mark_cleanup_end() {
-record_concurrent_mark_cleanup_end(size_t freed_bytes,
+double start_sec;
-size_t max_live_bytes) {
+if (G1PrintParCleanupStats) {
-double start;
+start_sec = os::elapsedTime();
-if (G1PrintParCleanupStats) start = os::elapsedTime();
+}
-record_concurrent_mark_cleanup_end_work1(freed_bytes, max_live_bytes);
 _collectionSetChooser->clearMarkedHeapRegions();
-double clear_marked_end;
+double clear_marked_end_sec;
 if (G1PrintParCleanupStats) {
-clear_marked_end = os::elapsedTime();
+clear_marked_end_sec = os::elapsedTime();
-gclog_or_tty->print_cr("  clear marked regions + work1: %8.3f ms.",
+gclog_or_tty->print_cr("  clear marked regions: %8.3f ms.",
-(clear_marked_end - start)*1000.0);
+(clear_marked_end_sec - start_sec) * 1000.0);
 }
 if (G1CollectedHeap::use_parallel_gc_threads()) {
 const size_t OverpartitionFactor = 4;
 const size_t MinWorkUnit = 8;
 const size_t WorkUnit =
 MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor),
 "sanity check");
 } else {
 KnownGarbageClosure knownGarbagecl(_collectionSetChooser);
 _g1->heap_region_iterate(&knownGarbagecl);
 }
-double known_garbage_end;
+double known_garbage_end_sec;
 if (G1PrintParCleanupStats) {
-known_garbage_end = os::elapsedTime();
+known_garbage_end_sec = os::elapsedTime();
 gclog_or_tty->print_cr("  compute known garbage: %8.3f ms.",
-(known_garbage_end - clear_marked_end)*1000.0);
+(known_garbage_end_sec - clear_marked_end_sec) * 1000.0);
 }
 _collectionSetChooser->sortMarkedHeapRegions();
-double sort_end;
+double end_sec = os::elapsedTime();
 if (G1PrintParCleanupStats) {
-sort_end = os::elapsedTime();
 gclog_or_tty->print_cr("  sorting: %8.3f ms.",
-(sort_end - known_garbage_end)*1000.0);
+(end_sec - known_garbage_end_sec) * 1000.0);
 }
-record_concurrent_mark_cleanup_end_work2();
+double elapsed_time_ms = (end_sec - _mark_cleanup_start_sec) * 1000.0;
-double work2_end;
+_concurrent_mark_cleanup_times_ms->add(elapsed_time_ms);
-if (G1PrintParCleanupStats) {
+_cur_mark_stop_world_time_ms += elapsed_time_ms;
-work2_end = os::elapsedTime();
+_prev_collection_pause_end_ms += elapsed_time_ms;
-gclog_or_tty->print_cr("  work2: %8.3f ms.",
+_mmu_tracker->add_pause(_mark_cleanup_start_sec, end_sec, true);
-(work2_end - sort_end)*1000.0);
-}
 }
 // Add the heap region at the head of the non-incremental collection set
 void G1CollectorPolicy::
 add_to_collection_set(HeapRegion* hr) {
 csr = next;
 }
 }
 #endif // !PRODUCT
-void
+void G1CollectorPolicy::choose_collection_set(double target_pause_time_ms) {
-G1CollectorPolicy_BestRegionsFirst::choose_collection_set(
-double target_pause_time_ms) {
 // Set this here - in case we're not doing young collections.
 double non_young_start_time_sec = os::elapsedTime();
 YoungList* young_list = _g1->young_list();
 double non_young_end_time_sec = os::elapsedTime();
 _recorded_non_young_cset_choice_time_ms =
 (non_young_end_time_sec - non_young_start_time_sec) * 1000.0;
 }
-void G1CollectorPolicy_BestRegionsFirst::record_full_collection_end() {
-G1CollectorPolicy::record_full_collection_end();
-_collectionSetChooser->updateAfterFullCollection();
-}
-void G1CollectorPolicy_BestRegionsFirst::
-record_collection_pause_end() {
-G1CollectorPolicy::record_collection_pause_end();
-assert(assertMarkedBytesDataOK(), "Marked regions not OK at pause end.");
-}

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp @ 4013:074f0252cc13