70 }; |
70 }; |
71 |
71 |
72 // </NEW PREDICTION> |
72 // </NEW PREDICTION> |
73 |
73 |
74 G1CollectorPolicy::G1CollectorPolicy() : |
74 G1CollectorPolicy::G1CollectorPolicy() : |
75 _parallel_gc_threads((ParallelGCThreads > 0) ? ParallelGCThreads : 1), |
75 _parallel_gc_threads(G1CollectedHeap::use_parallel_gc_threads() |
|
76 ? ParallelGCThreads : 1), |
|
77 |
|
78 |
76 _n_pauses(0), |
79 _n_pauses(0), |
77 _recent_CH_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
80 _recent_CH_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
78 _recent_G1_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
81 _recent_G1_strong_roots_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
79 _recent_evac_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
82 _recent_evac_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
80 _recent_pause_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
83 _recent_pause_times_ms(new TruncatedSeq(NumPrevPausesForHeuristics)), |
1071 gclog_or_tty->print(" "); |
1074 gclog_or_tty->print(" "); |
1072 gclog_or_tty->print_cr("[%s: %d]", str, value); |
1075 gclog_or_tty->print_cr("[%s: %d]", str, value); |
1073 } |
1076 } |
1074 |
1077 |
1075 double G1CollectorPolicy::avg_value (double* data) { |
1078 double G1CollectorPolicy::avg_value (double* data) { |
1076 if (ParallelGCThreads > 0) { |
1079 if (G1CollectedHeap::use_parallel_gc_threads()) { |
1077 double ret = 0.0; |
1080 double ret = 0.0; |
1078 for (uint i = 0; i < ParallelGCThreads; ++i) |
1081 for (uint i = 0; i < ParallelGCThreads; ++i) |
1079 ret += data[i]; |
1082 ret += data[i]; |
1080 return ret / (double) ParallelGCThreads; |
1083 return ret / (double) ParallelGCThreads; |
1081 } else { |
1084 } else { |
1082 return data[0]; |
1085 return data[0]; |
1083 } |
1086 } |
1084 } |
1087 } |
1085 |
1088 |
1086 double G1CollectorPolicy::max_value (double* data) { |
1089 double G1CollectorPolicy::max_value (double* data) { |
1087 if (ParallelGCThreads > 0) { |
1090 if (G1CollectedHeap::use_parallel_gc_threads()) { |
1088 double ret = data[0]; |
1091 double ret = data[0]; |
1089 for (uint i = 1; i < ParallelGCThreads; ++i) |
1092 for (uint i = 1; i < ParallelGCThreads; ++i) |
1090 if (data[i] > ret) |
1093 if (data[i] > ret) |
1091 ret = data[i]; |
1094 ret = data[i]; |
1092 return ret; |
1095 return ret; |
1108 |
1111 |
1109 double G1CollectorPolicy::max_sum (double* data1, |
1112 double G1CollectorPolicy::max_sum (double* data1, |
1110 double* data2) { |
1113 double* data2) { |
1111 double ret = data1[0] + data2[0]; |
1114 double ret = data1[0] + data2[0]; |
1112 |
1115 |
1113 if (ParallelGCThreads > 0) { |
1116 if (G1CollectedHeap::use_parallel_gc_threads()) { |
1114 for (uint i = 1; i < ParallelGCThreads; ++i) { |
1117 for (uint i = 1; i < ParallelGCThreads; ++i) { |
1115 double data = data1[i] + data2[i]; |
1118 double data = data1[i] + data2[i]; |
1116 if (data > ret) |
1119 if (data > ret) |
1117 ret = data; |
1120 ret = data; |
1118 } |
1121 } |
1124 #define MIN_TIMER_GRANULARITY 0.0000001 |
1127 #define MIN_TIMER_GRANULARITY 0.0000001 |
1125 |
1128 |
1126 void G1CollectorPolicy::record_collection_pause_end() { |
1129 void G1CollectorPolicy::record_collection_pause_end() { |
1127 double end_time_sec = os::elapsedTime(); |
1130 double end_time_sec = os::elapsedTime(); |
1128 double elapsed_ms = _last_pause_time_ms; |
1131 double elapsed_ms = _last_pause_time_ms; |
1129 bool parallel = ParallelGCThreads > 0; |
1132 bool parallel = G1CollectedHeap::use_parallel_gc_threads(); |
1130 double evac_ms = (end_time_sec - _cur_G1_strong_roots_end_sec) * 1000.0; |
1133 double evac_ms = (end_time_sec - _cur_G1_strong_roots_end_sec) * 1000.0; |
1131 size_t rs_size = |
1134 size_t rs_size = |
1132 _cur_collection_pause_used_regions_at_start - collection_set_size(); |
1135 _cur_collection_pause_used_regions_at_start - collection_set_size(); |
1133 size_t cur_used_bytes = _g1->used(); |
1136 size_t cur_used_bytes = _g1->used(); |
1134 assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); |
1137 assert(cur_used_bytes == _g1->recalculate_used(), "It should!"); |
1939 // We exempt parallel collection from this check because Alloc Buffer |
1942 // We exempt parallel collection from this check because Alloc Buffer |
1940 // fragmentation can produce negative collections. |
1943 // fragmentation can produce negative collections. |
1941 // Further, we're now always doing parallel collection. But I'm still |
1944 // Further, we're now always doing parallel collection. But I'm still |
1942 // leaving this here as a placeholder for a more precise assertion later. |
1945 // leaving this here as a placeholder for a more precise assertion later. |
1943 // (DLD, 10/05.) |
1946 // (DLD, 10/05.) |
1944 assert((true || ParallelGCThreads > 0) || |
1947 assert((true || G1CollectedHeap::use_parallel_gc_threads()) || |
1945 _g1->evacuation_failed() || |
1948 _g1->evacuation_failed() || |
1946 recent_survival_rate <= 1.0, "Or bad frac"); |
1949 recent_survival_rate <= 1.0, "Or bad frac"); |
1947 return recent_survival_rate; |
1950 return recent_survival_rate; |
1948 } else { |
1951 } else { |
1949 return 1.0; // Be conservative. |
1952 return 1.0; // Be conservative. |
1959 // We exempt parallel collection from this check because Alloc Buffer |
1962 // We exempt parallel collection from this check because Alloc Buffer |
1960 // fragmentation can produce negative collections. |
1963 // fragmentation can produce negative collections. |
1961 // Further, we're now always doing parallel collection. But I'm still |
1964 // Further, we're now always doing parallel collection. But I'm still |
1962 // leaving this here as a placeholder for a more precise assertion later. |
1965 // leaving this here as a placeholder for a more precise assertion later. |
1963 // (DLD, 10/05.) |
1966 // (DLD, 10/05.) |
1964 assert((true || ParallelGCThreads > 0) || |
1967 assert((true || G1CollectedHeap::use_parallel_gc_threads()) || |
1965 last_survival_rate <= 1.0, "Or bad frac"); |
1968 last_survival_rate <= 1.0, "Or bad frac"); |
1966 return last_survival_rate; |
1969 return last_survival_rate; |
1967 } else { |
1970 } else { |
1968 return 1.0; |
1971 return 1.0; |
1969 } |
1972 } |
2119 if (should_print) |
2122 if (should_print) |
2120 print_summary(level, "Other(Calc)", calc_other_times_ms); |
2123 print_summary(level, "Other(Calc)", calc_other_times_ms); |
2121 } |
2124 } |
2122 |
2125 |
2123 void G1CollectorPolicy::print_summary(PauseSummary* summary) const { |
2126 void G1CollectorPolicy::print_summary(PauseSummary* summary) const { |
2124 bool parallel = ParallelGCThreads > 0; |
2127 bool parallel = G1CollectedHeap::use_parallel_gc_threads(); |
2125 MainBodySummary* body_summary = summary->main_body_summary(); |
2128 MainBodySummary* body_summary = summary->main_body_summary(); |
2126 if (summary->get_total_seq()->num() > 0) { |
2129 if (summary->get_total_seq()->num() > 0) { |
2127 print_summary_sd(0, "Evacuation Pauses", summary->get_total_seq()); |
2130 print_summary_sd(0, "Evacuation Pauses", summary->get_total_seq()); |
2128 if (body_summary != NULL) { |
2131 if (body_summary != NULL) { |
2129 print_summary(1, "SATB Drain", body_summary->get_satb_drain_seq()); |
2132 print_summary(1, "SATB Drain", body_summary->get_satb_drain_seq()); |
2557 if (G1PrintParCleanupStats) { |
2560 if (G1PrintParCleanupStats) { |
2558 clear_marked_end = os::elapsedTime(); |
2561 clear_marked_end = os::elapsedTime(); |
2559 gclog_or_tty->print_cr(" clear marked regions + work1: %8.3f ms.", |
2562 gclog_or_tty->print_cr(" clear marked regions + work1: %8.3f ms.", |
2560 (clear_marked_end - start)*1000.0); |
2563 (clear_marked_end - start)*1000.0); |
2561 } |
2564 } |
2562 if (ParallelGCThreads > 0) { |
2565 if (G1CollectedHeap::use_parallel_gc_threads()) { |
2563 const size_t OverpartitionFactor = 4; |
2566 const size_t OverpartitionFactor = 4; |
2564 const size_t MinWorkUnit = 8; |
2567 const size_t MinWorkUnit = 8; |
2565 const size_t WorkUnit = |
2568 const size_t WorkUnit = |
2566 MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor), |
2569 MAX2(_g1->n_regions() / (ParallelGCThreads * OverpartitionFactor), |
2567 MinWorkUnit); |
2570 MinWorkUnit); |