src/share/vm/gc/g1/g1GCPhaseTimes.cpp

*** 104,162 ****
        _gc_par_phases[i]->reset();
      }
    }
  }
  
! #define ASSERT_PHASE_UNINITILAIZED(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)
  
  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();
  
    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);
  
!       record_time_secs(Other, i, worker_time - worker_known_time);
      }
    }
  }
  
! #undef ADD_WORKER_KNOWN_TIME
! #undef ASSERT_PHASE_UNINITILAIZED
  
  // record the time a phase took in seconds
  void G1GCPhaseTimes::record_time_secs(GCParPhases phase, uint worker_i, double secs) {
    _gc_par_phases[phase]->set(worker_i, secs);
  }
--- 104,161 ----
        _gc_par_phases[i]->reset();
      }
    }
  }
  
! #define ASSERT_PHASE_UNINITILIAZED(phase) \
      assert(_gc_par_phases[phase]->get(i) == uninitialized, "Phase " #phase " reported for thread that was not started");
  
! 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 = 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) {
!       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, 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 ASSERT_PHASE_UNINITILIAZED
  
  // record the time a phase took in seconds
  void G1GCPhaseTimes::record_time_secs(GCParPhases phase, uint worker_i, double secs) {
    _gc_par_phases[phase]->set(worker_i, secs);
  }