< prev index next >
src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp
Print this page
@@ -71,17 +71,21 @@
va_start(ap, format);
vappend(format, ap);
va_end(ap);
}
+ void print_cr() {
+ gclog_or_tty->print_cr("%s", _buffer);
+ _cur = _indent_level * INDENT_CHARS;
+ }
+
void append_and_print_cr(const char* format, ...) ATTRIBUTE_PRINTF(2, 3) {
va_list ap;
va_start(ap, format);
vappend(format, ap);
va_end(ap);
- gclog_or_tty->print_cr("%s", _buffer);
- _cur = _indent_level * INDENT_CHARS;
+ print_cr();
}
};
template <class T>
WorkerDataArray<T>::WorkerDataArray(uint length, const char* title, bool print_sum, int log_level, uint indent_level) :
@@ -95,19 +99,11 @@
template <class T>
WorkerDataArray<T>::~WorkerDataArray() {
FREE_C_HEAP_ARRAY(T, _data);
}
-template <>
-void WorkerDataArray<double>::log_value(LineBuffer& buf, double value) {
- buf.append("%.1lf", value * 1000);
-}
-
-template <>
-void WorkerDataArray<size_t>::log_value(LineBuffer& buf, size_t value) {
- buf.append(SIZE_FORMAT, value);
-}
+#ifndef PRODUCT
template <>
size_t WorkerDataArray<size_t>::uninitialized() {
return (size_t)-1;
}
@@ -116,70 +112,10 @@
double WorkerDataArray<double>::uninitialized() {
return -1.0;
}
template <class T>
-void WorkerDataArray<T>::print() {
- if (_log_level > G1Log::level() || !_enabled) {
- return;
- }
-
- if (_length == 1) {
- // No need for min, max, average and sum for only one worker
- LineBuffer buf(_indent_level);
- buf.append("[%s: ", _title);
- log_value(buf, _data[0]);
- buf.append_and_print_cr("]");
- return;
- }
-
- T min = _data[0];
- T max = _data[0];
- T sum = 0;
-
- LineBuffer buf(_indent_level);
- buf.append("[%s:", _title);
- for (uint i = 0; i < _length; ++i) {
- T val = _data[i];
- min = MIN2(val, min);
- max = MAX2(val, max);
- sum += val;
- if (G1Log::finest()) {
- buf.append(" ");
- log_value(buf, val);
- }
- }
-
- if (G1Log::finest()) {
- buf.append_and_print_cr("%s", "");
- }
-
- double avg = (double)sum / (double)_length;
- buf.append(" Min: ");
- log_value(buf, min);
- buf.append(", Avg: ");
- buf.append("%.1lf", avg); // Always print average as a double
- buf.append(", Max: ");
- log_value(buf, max);
- buf.append(", Diff: ");
- log_value(buf, max - min);
- if (_print_sum) {
- // for things like the start and end times the sum is not
- // that relevant
- buf.append(", Sum: ");
- log_value(buf, sum);
- }
- buf.append_and_print_cr("]");
-
- if (_sub_count != NULL) {
- _sub_count->print();
- }
-}
-
-#ifndef PRODUCT
-
-template <class T>
void WorkerDataArray<T>::reset() {
for (uint i = 0; i < _length; i++) {
_data[i] = WorkerDataArray<T>::uninitialized();
}
if (_sub_count != NULL) {
@@ -243,29 +179,29 @@
_gc_phases[i]->reset();
}
_gc_phases[SATBFiltering]->set_enabled(mark_in_progress);
- _gc_phases[StringDedupQueueFixup]->set_enabled(G1StringDedup::is_enabled);
- _gc_phases[StringDedupTableFixup]->set_enabled(G1StringDedup::is_enabled);
+ _gc_phases[StringDedupQueueFixup]->set_enabled(G1StringDedup::is_enabled());
+ _gc_phases[StringDedupTableFixup]->set_enabled(G1StringDedup::is_enabled());
}
void G1GCPhaseTimes::note_gc_end() {
for (uint i = 0; i < _active_gc_threads; i++) {
double worker_time = _gc_phases[GCWorkerEnd]->get(i) - _gc_phases[GCWorkerStart]->get(i);
- record_time(GCWorkerTotal, i , worker_time);
+ record_time_secs(GCWorkerTotal, i , worker_time);
double worker_known_time =
_gc_phases[ExtRootScan]->get(i) +
_gc_phases[SATBFiltering]->get(i) +
_gc_phases[UpdateRS]->get(i) +
_gc_phases[ScanRS]->get(i) +
_gc_phases[CodeRoots]->get(i) +
_gc_phases[ObjCopy]->get(i) +
_gc_phases[Termination]->get(i);
- record_time(Other, i, worker_time - worker_known_time);
+ record_time_secs(Other, i, worker_time - worker_known_time);
}
for (int i = 0; i < Sentinel; i++) {
_gc_phases[i]->verify();
}
@@ -307,25 +243,27 @@
return misc_time_ms;
}
void G1GCPhaseTimes::print(double pause_time_sec) {
+ G1GCPhasePrinter phase_printer(this);
+
if (_root_region_scan_wait_time_ms > 0.0) {
print_stats(1, "Root Region Scan Waiting", _root_region_scan_wait_time_ms);
}
print_stats(1, "Parallel Time", _cur_collection_par_time_ms, _active_gc_threads);
for (int i = 0; i <= GCMainPhasesLast; i++) {
- _gc_phases[i]->print();
+ phase_printer.print((GCPhases) i);
}
print_stats(1, "Code Root Fixup", _cur_collection_code_root_fixup_time_ms);
print_stats(1, "Code Root Purge", _cur_strong_code_root_purge_time_ms);
if (G1StringDedup::is_enabled()) {
print_stats(1, "String Dedup Fixup", _cur_string_dedup_fixup_time_ms, _active_gc_threads);
for (int i = StringDedupPhasesFirst; i <= StringDedupPhasesLast; i++) {
- _gc_phases[i]->print();
+ phase_printer.print((GCPhases) i);
}
}
print_stats(1, "Clear CT", _cur_clear_ct_time_ms);
double misc_time_ms = pause_time_sec * MILLIUNITS - accounted_time_ms();
print_stats(1, "Other", misc_time_ms);
@@ -346,11 +284,11 @@
(_recorded_young_cset_choice_time_ms +
_recorded_non_young_cset_choice_time_ms));
print_stats(2, "Ref Proc", _cur_ref_proc_time_ms);
print_stats(2, "Ref Enq", _cur_ref_enq_time_ms);
print_stats(2, "Redirty Cards", _recorded_redirty_logged_cards_time_ms);
- _gc_phases[RedirtyCards]->print();
+ phase_printer.print(RedirtyCards);
if (G1EagerReclaimHumongousObjects) {
print_stats(2, "Humongous Register", _cur_fast_reclaim_humongous_register_time_ms);
if (G1Log::finest()) {
print_stats(3, "Humongous Total", _cur_fast_reclaim_humongous_total);
print_stats(3, "Humongous Candidate", _cur_fast_reclaim_humongous_candidates);
@@ -376,7 +314,86 @@
_phase_times(phase_times), _phase(phase), _worker_id(worker_id) {
_start_time = os::elapsedTime();
}
G1GCPhaseTimesTracker::~G1GCPhaseTimesTracker() {
- _phase_times->record_time(_phase, _worker_id, os::elapsedTime() - _start_time);
+ _phase_times->record_time_secs(_phase, _worker_id, os::elapsedTime() - _start_time);
+}
+
+void G1GCPhasePrinter::print_single_length(G1GCPhaseTimes::GCPhases phase_id, WorkerDataArray<double>* phase) {
+ // No need for min, max, average and sum for only one worker
+ LineBuffer buf(phase->_indent_level);
+ buf.append_and_print_cr("[%s: %.1lf]", phase->_title, _phase_times->get_time_ms(phase_id, 0));
+
+ if (phase->_sub_count != NULL) {
+ LineBuffer buf2(phase->_sub_count->_indent_level);
+ buf2.append_and_print_cr("[%s: "SIZE_FORMAT"]", phase->_sub_count->_title, _phase_times->sub_count_sum(phase_id));
+ }
+}
+
+void G1GCPhasePrinter::print_time_values(LineBuffer& buf, G1GCPhaseTimes::GCPhases phase_id, WorkerDataArray<double>* phase) {
+ for (uint i = 0; i < phase->_length; ++i) {
+ buf.append(" %.1lf", _phase_times->get_time_ms(phase_id, i));
+ }
+ buf.print_cr();
+}
+
+void G1GCPhasePrinter::print_count_values(LineBuffer& buf, G1GCPhaseTimes::GCPhases phase_id, WorkerDataArray<size_t>* sub_count) {
+ for (uint i = 0; i < sub_count->_length; ++i) {
+ buf.append(" " SIZE_FORMAT, _phase_times->get_sub_count(phase_id, i));
+ }
+ buf.print_cr();
+}
+
+void G1GCPhasePrinter::print_sub_count(G1GCPhaseTimes::GCPhases phase_id, WorkerDataArray<size_t>* sub_count) {
+ LineBuffer buf(sub_count->_indent_level);
+ buf.append("[%s:", sub_count->_title);
+
+ if (G1Log::finest()) {
+ print_count_values(buf, phase_id, sub_count);
+ }
+
+ assert(sub_count->_print_sum, err_msg("%s does not have print sum true even though it is a count", sub_count->_title));
+
+ buf.append_and_print_cr(" Min: " SIZE_FORMAT ", Avg: %.1lf, Max: " SIZE_FORMAT ", Diff: " SIZE_FORMAT ", Sum: " SIZE_FORMAT "]",
+ _phase_times->min_sub_count(phase_id), _phase_times->average_sub_count(phase_id), _phase_times->max_sub_count(phase_id),
+ _phase_times->max_sub_count(phase_id) - _phase_times->min_sub_count(phase_id), _phase_times->sum_sub_count(phase_id));
+}
+
+void G1GCPhasePrinter::print_multi_length(G1GCPhaseTimes::GCPhases phase_id, WorkerDataArray<double>* phase) {
+ LineBuffer buf(phase->_indent_level);
+ buf.append("[%s:", phase->_title);
+
+ if (G1Log::finest()) {
+ print_time_values(buf, phase_id, phase);
+ }
+
+ buf.append(" Min: %.1lf, Avg: %.1lf, Max: %.1lf, Diff: %.1lf",
+ _phase_times->min_time_ms(phase_id), _phase_times->average_time_ms(phase_id), _phase_times->max_time_ms(phase_id),
+ _phase_times->max_time_ms(phase_id) - _phase_times->min_time_ms(phase_id));
+
+ if (phase->_print_sum) {
+ // for things like the start and end times the sum is not
+ // that relevant
+ buf.append(", Sum: %.1lf", _phase_times->sum_time_ms(phase_id));
+ }
+
+ buf.append_and_print_cr("]");
+
+ if (phase->_sub_count != NULL) {
+ print_sub_count(phase_id, phase->_sub_count);
+ }
+}
+
+void G1GCPhasePrinter::print(G1GCPhaseTimes::GCPhases phase_id) {
+ WorkerDataArray<double>* phase = _phase_times->_gc_phases[phase_id];
+
+ if (phase->_log_level > G1Log::level() || !phase->_enabled) {
+ return;
+ }
+
+ if (phase->_length == 1) {
+ print_single_length(phase_id, phase);
+ } else {
+ print_multi_length(phase_id, phase);
+ }
}
< prev index next >