--- old/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp	2015-02-27 15:19:10.846465563 +0100
+++ new/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp	2015-02-27 15:19:10.750465567 +0100
@@ -84,8 +84,9 @@
 };
 
 template <class T>
-WorkerDataArray<T>::WorkerDataArray(uint length, const char* title, bool print_sum, uint indent_level) :
-  _title(title), _length(0), _print_sum(print_sum), _indent_level(indent_level), _has_new_data(true), _sub_count(NULL), _enabled(true) {
+WorkerDataArray<T>::WorkerDataArray(uint length, const char* title, bool print_sum, int log_level, uint indent_level) :
+  _title(title), _length(0), _print_sum(print_sum), _log_level(log_level), _indent_level(indent_level),
+  _has_new_data(true), _sub_count(NULL), _enabled(true) {
   assert(length > 0, "Must have some workers to store data for");
   _length = length;
   _data = NEW_C_HEAP_ARRAY(T, _length, mtGC);
@@ -118,6 +119,10 @@
 
 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);
@@ -165,7 +170,7 @@
   }
   buf.append_and_print_cr("]");
 
-  if (_sub_count != NULL && _sub_count->enabled()) {
+  if (_sub_count != NULL) {
     _sub_count->print();
   }
 }
@@ -203,29 +208,29 @@
 {
   assert(max_gc_threads > 0, "Must have some GC threads");
 
-  _gc_phases[GCWorkerStart] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Start (ms)", false, 2);
-  _gc_phases[ExtRootScan] = new WorkerDataArray<double>(max_gc_threads, "Ext Root Scanning (ms)", true, 2);
-  _gc_phases[SATBFiltering] = new WorkerDataArray<double>(max_gc_threads, "SATB Filtering (ms)", true, 2);
-  _gc_phases[UpdateRS] = new WorkerDataArray<double>(max_gc_threads, "Update RS (ms)", true, 2);
-  _gc_phases[ScanRS] = new WorkerDataArray<double>(max_gc_threads, "Scan RS (ms)", true, 2);
-  _gc_phases[CodeRoots] = new WorkerDataArray<double>(max_gc_threads, "Code Root Scanning (ms)", true, 2);
-  _gc_phases[ObjCopy] = new WorkerDataArray<double>(max_gc_threads, "Object Copy (ms)", true, 2);
-  _gc_phases[Termination] = new WorkerDataArray<double>(max_gc_threads, "Termination (ms)", true, 2);
-  _gc_phases[GCWorkerTotal] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Total (ms)", true, 2);
-  _gc_phases[GCWorkerEnd] = new WorkerDataArray<double>(max_gc_threads, "GC Worker End (ms)", false, 2);
-  _gc_phases[Other] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Other (ms)", true, 2);
+  _gc_phases[GCWorkerStart] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Start (ms)", false, G1Log::LevelFiner, 2);
+  _gc_phases[ExtRootScan] = new WorkerDataArray<double>(max_gc_threads, "Ext Root Scanning (ms)", true, G1Log::LevelFiner, 2);
+  _gc_phases[SATBFiltering] = new WorkerDataArray<double>(max_gc_threads, "SATB Filtering (ms)", true, G1Log::LevelFiner, 2);
+  _gc_phases[UpdateRS] = new WorkerDataArray<double>(max_gc_threads, "Update RS (ms)", true, G1Log::LevelFiner, 2);
+  _gc_phases[ScanRS] = new WorkerDataArray<double>(max_gc_threads, "Scan RS (ms)", true, G1Log::LevelFiner, 2);
+  _gc_phases[CodeRoots] = new WorkerDataArray<double>(max_gc_threads, "Code Root Scanning (ms)", true, G1Log::LevelFiner, 2);
+  _gc_phases[ObjCopy] = new WorkerDataArray<double>(max_gc_threads, "Object Copy (ms)", true, G1Log::LevelFiner, 2);
+  _gc_phases[Termination] = new WorkerDataArray<double>(max_gc_threads, "Termination (ms)", true, G1Log::LevelFiner, 2);
+  _gc_phases[GCWorkerTotal] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Total (ms)", true, G1Log::LevelFiner, 2);
+  _gc_phases[GCWorkerEnd] = new WorkerDataArray<double>(max_gc_threads, "GC Worker End (ms)", false, G1Log::LevelFiner, 2);
+  _gc_phases[Other] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Other (ms)", true, G1Log::LevelFiner, 2);
 
-  _update_rs_processed_buffers = new WorkerDataArray<size_t>(max_gc_threads, "Processed Buffers", true, 3);
+  _update_rs_processed_buffers = new WorkerDataArray<size_t>(max_gc_threads, "Processed Buffers", true, G1Log::LevelFiner, 3);
   _gc_phases[UpdateRS]->link_sub_count_array(_update_rs_processed_buffers);
 
-  _termination_attempts = new WorkerDataArray<size_t>(max_gc_threads, "Termination Attempts", true, 3);
+  _termination_attempts = new WorkerDataArray<size_t>(max_gc_threads, "Termination Attempts", true, G1Log::LevelFinest, 3);
   _gc_phases[Termination]->link_sub_count_array(_termination_attempts);
 
-  _gc_phases[StringDedupQueueFixup] = new WorkerDataArray<double>(max_gc_threads, "Queue Fixup (ms)", true, 2);
-  _gc_phases[StringDedupTableFixup] = new WorkerDataArray<double>(max_gc_threads, "Table Fixup (ms)", true, 2);
+  _gc_phases[StringDedupQueueFixup] = new WorkerDataArray<double>(max_gc_threads, "Queue Fixup (ms)", true, G1Log::LevelFiner, 2);
+  _gc_phases[StringDedupTableFixup] = new WorkerDataArray<double>(max_gc_threads, "Table Fixup (ms)", true, G1Log::LevelFiner, 2);
 
-  _gc_phases[RedirtyCards] = new WorkerDataArray<double>(max_gc_threads, "Parallel Redirty", true, 3);
-  _redirtied_cards = new WorkerDataArray<size_t>(max_gc_threads, "Redirtied Cards", true, 3);
+  _gc_phases[RedirtyCards] = new WorkerDataArray<double>(max_gc_threads, "Parallel Redirty", true, G1Log::LevelFinest, 3);
+  _redirtied_cards = new WorkerDataArray<size_t>(max_gc_threads, "Redirtied Cards", true, G1Log::LevelFinest, 3);
   _gc_phases[RedirtyCards]->link_sub_count_array(_redirtied_cards);
 }
 
@@ -238,20 +243,10 @@
     _gc_phases[i]->reset();
   }
 
-  if (!G1Log::finest()) {
-    _termination_attempts->disable();
-  }
-
-  if (mark_in_progress) {
-    _gc_phases[SATBFiltering]->enable();
-  } else {
-    _gc_phases[SATBFiltering]->disable();
-  }
+  _gc_phases[SATBFiltering]->set_enabled(mark_in_progress);
 
-  if (!G1StringDedup::is_enabled()) {
-    _gc_phases[StringDedupQueueFixup]->disable();
-    _gc_phases[StringDedupTableFixup]->disable();
-  }
+  _gc_phases[StringDedupQueueFixup]->set_enabled(G1StringDedup::is_enabled);
+  _gc_phases[StringDedupTableFixup]->set_enabled(G1StringDedup::is_enabled);
 }
 
 void G1GCPhaseTimes::note_gc_end() {
@@ -261,23 +256,18 @@
 
     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);
 
-    if (_gc_phases[SATBFiltering]->enabled()) {
-      worker_known_time += _gc_phases[SATBFiltering]->get(i);
-    }
-
     record_time(Other, i, worker_time - worker_known_time);
   }
 
   for (int i = 0; i < Sentinel; i++) {
-    if (_gc_phases[i]->enabled()) {
-      _gc_phases[i]->verify();
-    }
+    _gc_phases[i]->verify();
   }
 }
 
@@ -325,9 +315,7 @@
 
   print_stats(1, "Parallel Time", _cur_collection_par_time_ms, _active_gc_threads);
   for (int i = 0; i <= GCMainPhasesLast; i++) {
-    if (_gc_phases[i]->enabled()) {
-      _gc_phases[i]->print();
-    }
+    _gc_phases[i]->print();
   }
 
   print_stats(1, "Code Root Fixup", _cur_collection_code_root_fixup_time_ms);
@@ -335,9 +323,7 @@
   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++) {
-      if (_gc_phases[i]->enabled()) {
-        _gc_phases[i]->print();
-      }
+      _gc_phases[i]->print();
     }
   }
   print_stats(1, "Clear CT", _cur_clear_ct_time_ms);
@@ -362,9 +348,7 @@
   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);
-  if (G1Log::finest()) {
-    _gc_phases[RedirtyCards]->print();
-  }
+  _gc_phases[RedirtyCards]->print();
   if (G1EagerReclaimHumongousObjects) {
     print_stats(2, "Humongous Register", _cur_fast_reclaim_humongous_register_time_ms);
     if (G1Log::finest()) {