--- old/src/share/vm/gc/g1/g1GCPhaseTimes.cpp	2016-03-30 16:04:37.484788991 +0200
+++ new/src/share/vm/gc/g1/g1GCPhaseTimes.cpp	2016-03-30 16:04:37.344788985 +0200
@@ -106,55 +106,54 @@
   }
 }
 
-#define ASSERT_PHASE_UNINITILAIZED(phase) \
+#define ASSERT_PHASE_UNINITILIAZED(phase) \
     assert(_gc_par_phases[phase]->get(i) == uninitialized, "Phase " #phase " reported for thread that was not started");
 
-#define ADD_WORKER_KNOWN_TIME(phase)                \
-    do {                                            \
-      double value = _gc_par_phases[phase]->get(i); \
-      if (value != uninitialized) {                 \
-        worker_known_time += value;                 \
-      }                                             \
-    } while(false)
+double G1GCPhaseTimes::worker_time(GCParPhases phase, uint worker) {
+  double value = _gc_par_phases[phase]->get(worker);
+  if (value != WorkerDataArray<double>::uninitialized()) {
+    return value;
+  }
+  return 0.0;
+}
 
 void G1GCPhaseTimes::note_gc_end() {
   _gc_pause_time_ms = TimeHelper::counter_to_millis(os::elapsed_counter() - _gc_start_counter);
 
-  double uninitialized = _gc_par_phases[GCWorkerStart]->uninitialized();
+  double uninitialized = WorkerDataArray<double>::uninitialized();
 
   for (uint i = 0; i < _max_gc_threads; i++) {
     double worker_start = _gc_par_phases[GCWorkerStart]->get(i);
-    if (worker_start == uninitialized) {
-      // Make sure all slots are uninitialized since this thread did not seem to have been started
-      ASSERT_PHASE_UNINITILAIZED(GCWorkerEnd);
-      ASSERT_PHASE_UNINITILAIZED(ExtRootScan);
-      ASSERT_PHASE_UNINITILAIZED(SATBFiltering);
-      ASSERT_PHASE_UNINITILAIZED(UpdateRS);
-      ASSERT_PHASE_UNINITILAIZED(ScanRS);
-      ASSERT_PHASE_UNINITILAIZED(CodeRoots);
-      ASSERT_PHASE_UNINITILAIZED(ObjCopy);
-      ASSERT_PHASE_UNINITILAIZED(Termination);
-    } else {
-      assert(_gc_par_phases[GCWorkerEnd]->get(i) != _gc_par_phases[GCWorkerEnd]->uninitialized(), "Worker started but not ended.");
-      double worker_time = _gc_par_phases[GCWorkerEnd]->get(i) - _gc_par_phases[GCWorkerStart]->get(i);
-      record_time_secs(GCWorkerTotal, i , worker_time);
-
-      double worker_known_time = 0.0;
-      ADD_WORKER_KNOWN_TIME(ExtRootScan);
-      ADD_WORKER_KNOWN_TIME(SATBFiltering);
-      ADD_WORKER_KNOWN_TIME(UpdateRS);
-      ADD_WORKER_KNOWN_TIME(ScanRS);
-      ADD_WORKER_KNOWN_TIME(CodeRoots);
-      ADD_WORKER_KNOWN_TIME(ObjCopy);
-      ADD_WORKER_KNOWN_TIME(Termination);
+    if (worker_start != uninitialized) {
+      assert(_gc_par_phases[GCWorkerEnd]->get(i) != uninitialized, "Worker started but not ended.");
+      double total_worker_time = _gc_par_phases[GCWorkerEnd]->get(i) - _gc_par_phases[GCWorkerStart]->get(i);
+      record_time_secs(GCWorkerTotal, i , total_worker_time);
+
+      double worker_known_time =
+          worker_time(ExtRootScan, i)
+          + worker_time(SATBFiltering, i)
+          + worker_time(UpdateRS, i)
+          + worker_time(ScanRS, i)
+          + worker_time(CodeRoots, i)
+          + worker_time(ObjCopy, i)
+          + worker_time(Termination, i);
 
-      record_time_secs(Other, i, worker_time - worker_known_time);
+      record_time_secs(Other, i, total_worker_time - worker_known_time);
+    } else {
+      // Make sure all slots are uninitialized since this thread did not seem to have been started
+      ASSERT_PHASE_UNINITILIAZED(GCWorkerEnd);
+      ASSERT_PHASE_UNINITILIAZED(ExtRootScan);
+      ASSERT_PHASE_UNINITILIAZED(SATBFiltering);
+      ASSERT_PHASE_UNINITILIAZED(UpdateRS);
+      ASSERT_PHASE_UNINITILIAZED(ScanRS);
+      ASSERT_PHASE_UNINITILIAZED(CodeRoots);
+      ASSERT_PHASE_UNINITILIAZED(ObjCopy);
+      ASSERT_PHASE_UNINITILIAZED(Termination);
     }
   }
 }
 
-#undef ADD_WORKER_KNOWN_TIME
-#undef ASSERT_PHASE_UNINITILAIZED
+#undef ASSERT_PHASE_UNINITILIAZED
 
 // record the time a phase took in seconds
 void G1GCPhaseTimes::record_time_secs(GCParPhases phase, uint worker_i, double secs) {