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

rev 52675 : 8213890: Implementation of JEP 344: Abortable Mixed Collections for G1
Reviewed-by:
Contributed-by: erik.helin@oracle.com, stefan.johansson@oracle.com
rev 52676 : imported patch AMGC-impl
rev 52679 : imported patch AMGC-tsch-rev1-log
rev 52681 : [mq]: AMGC-kbar-rev1

@@ -71,15 +71,17 @@
     _gc_par_phases[ScanHCC] = new WorkerDataArray<double>(max_gc_threads, "Scan HCC (ms):");
   } else {
     _gc_par_phases[ScanHCC] = NULL;
   }
   _gc_par_phases[ScanRS] = new WorkerDataArray<double>(max_gc_threads, "Scan RS (ms):");
+  _gc_par_phases[OptScanRS] = new WorkerDataArray<double>(max_gc_threads, "Optional Scan RS (ms):");
   _gc_par_phases[CodeRoots] = new WorkerDataArray<double>(max_gc_threads, "Code Root Scanning (ms):");
 #if INCLUDE_AOT
   _gc_par_phases[AOTCodeRoots] = new WorkerDataArray<double>(max_gc_threads, "AOT Root Scanning (ms):");
 #endif
   _gc_par_phases[ObjCopy] = new WorkerDataArray<double>(max_gc_threads, "Object Copy (ms):");
+  _gc_par_phases[OptObjCopy] = new WorkerDataArray<double>(max_gc_threads, "Optional Object Copy (ms):");
   _gc_par_phases[Termination] = new WorkerDataArray<double>(max_gc_threads, "Termination (ms):");
   _gc_par_phases[GCWorkerTotal] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Total (ms):");
   _gc_par_phases[GCWorkerEnd] = new WorkerDataArray<double>(max_gc_threads, "GC Worker End (ms):");
   _gc_par_phases[Other] = new WorkerDataArray<double>(max_gc_threads, "GC Worker Other (ms):");
 

@@ -88,10 +90,19 @@
   _scan_rs_claimed_cards = new WorkerDataArray<size_t>(max_gc_threads, "Claimed Cards:");
   _gc_par_phases[ScanRS]->link_thread_work_items(_scan_rs_claimed_cards, ScanRSClaimedCards);
   _scan_rs_skipped_cards = new WorkerDataArray<size_t>(max_gc_threads, "Skipped Cards:");
   _gc_par_phases[ScanRS]->link_thread_work_items(_scan_rs_skipped_cards, ScanRSSkippedCards);
 
+  _opt_cset_scanned_cards = new WorkerDataArray<size_t>(max_gc_threads, "Scanned Cards:");
+  _gc_par_phases[OptScanRS]->link_thread_work_items(_opt_cset_scanned_cards, OptCSetScannedCards);
+  _opt_cset_claimed_cards = new WorkerDataArray<size_t>(max_gc_threads, "Claimed Cards:");
+  _gc_par_phases[OptScanRS]->link_thread_work_items(_opt_cset_claimed_cards, OptCSetClaimedCards);
+  _opt_cset_skipped_cards = new WorkerDataArray<size_t>(max_gc_threads, "Skipped Cards:");
+  _gc_par_phases[OptScanRS]->link_thread_work_items(_opt_cset_skipped_cards, OptCSetSkippedCards);
+  _opt_cset_used_memory = new WorkerDataArray<size_t>(max_gc_threads, "Used Memory:");
+  _gc_par_phases[OptScanRS]->link_thread_work_items(_opt_cset_used_memory, OptCSetUsedMemory);
+
   _update_rs_processed_buffers = new WorkerDataArray<size_t>(max_gc_threads, "Processed Buffers:");
   _gc_par_phases[UpdateRS]->link_thread_work_items(_update_rs_processed_buffers, UpdateRSProcessedBuffers);
   _update_rs_scanned_cards = new WorkerDataArray<size_t>(max_gc_threads, "Scanned Cards:");
   _gc_par_phases[UpdateRS]->link_thread_work_items(_update_rs_scanned_cards, UpdateRSScannedCards);
   _update_rs_skipped_cards = new WorkerDataArray<size_t>(max_gc_threads, "Skipped Cards:");

@@ -118,10 +129,11 @@
   reset();
 }
 
 void G1GCPhaseTimes::reset() {
   _cur_collection_par_time_ms = 0.0;
+  _cur_optional_evac_ms = 0.0;
   _cur_collection_code_root_fixup_time_ms = 0.0;
   _cur_strong_code_root_purge_time_ms = 0.0;
   _cur_evac_fail_recalc_used = 0.0;
   _cur_evac_fail_remove_self_forwards = 0.0;
   _cur_string_dedup_fixup_time_ms = 0.0;

@@ -225,22 +237,26 @@
 // add a number of seconds to a phase
 void G1GCPhaseTimes::add_time_secs(GCParPhases phase, uint worker_i, double secs) {
   _gc_par_phases[phase]->add(worker_i, secs);
 }
 
-void G1GCPhaseTimes::record_or_add_objcopy_time_secs(uint worker_i, double secs) {
-  if (_gc_par_phases[ObjCopy]->get(worker_i) == _gc_par_phases[ObjCopy]->uninitialized()) {
-    record_time_secs(ObjCopy, worker_i, secs);
+void G1GCPhaseTimes::record_or_add_time_secs(GCParPhases phase, uint worker_i, double secs) {
+  if (_gc_par_phases[phase]->get(worker_i) == _gc_par_phases[phase]->uninitialized()) {
+    record_time_secs(phase, worker_i, secs);
   } else {
-    add_time_secs(ObjCopy, worker_i, secs);
+    add_time_secs(phase, worker_i, secs);
   }
 }
 
 void G1GCPhaseTimes::record_thread_work_item(GCParPhases phase, uint worker_i, size_t count, uint index) {
   _gc_par_phases[phase]->set_thread_work_item(worker_i, count, index);
 }
 
+void G1GCPhaseTimes::record_or_add_thread_work_item(GCParPhases phase, uint worker_i, size_t count, uint index) {
+  _gc_par_phases[phase]->set_or_add_thread_work_item(worker_i, count, index);
+}
+
 // return the average time for a phase in milliseconds
 double G1GCPhaseTimes::average_time_ms(GCParPhases phase) {
   return _gc_par_phases[phase]->average() * 1000.0;
 }
 

@@ -346,10 +362,20 @@
     debug_time("Clear Claimed Marks", _recorded_clear_claimed_marks_time_ms);
   }
   return sum_ms;
 }
 
+double G1GCPhaseTimes::print_evacuate_optional_collection_set() const {
+  const double sum_ms = _cur_optional_evac_ms;
+  if (sum_ms > 0) {
+    info_time("Evacuate Optional Collection Set", sum_ms);
+    debug_phase(_gc_par_phases[OptScanRS]);
+    debug_phase(_gc_par_phases[OptObjCopy]);
+  }
+  return sum_ms;
+}
+
 double G1GCPhaseTimes::print_evacuate_collection_set() const {
   const double sum_ms = _cur_collection_par_time_ms;
 
   info_time("Evacuate Collection Set", sum_ms);
 

@@ -455,10 +481,11 @@
   }
 
   double accounted_ms = 0.0;
   accounted_ms += print_pre_evacuate_collection_set();
   accounted_ms += print_evacuate_collection_set();
+  accounted_ms += print_evacuate_optional_collection_set();
   accounted_ms += print_post_evacuate_collection_set();
   print_other(accounted_ms);
 
   if (_cur_verify_after_time_ms > 0.0) {
     debug_time("Verify After", _cur_verify_after_time_ms);

@@ -483,15 +510,17 @@
       "WeakCLDRoots",
       "SATBFiltering",
       "UpdateRS",
       "ScanHCC",
       "ScanRS",
+      "OptScanRS",
       "CodeRoots",
 #if INCLUDE_AOT
       "AOTCodeRoots",
 #endif
       "ObjCopy",
+      "OptObjCopy",
       "Termination",
       "Other",
       "GCWorkerTotal",
       "GCWorkerEnd",
       "StringDedupQueueFixup",

@@ -559,9 +588,9 @@
   if (_phase_times != NULL) {
     // Explicitly stop the trim tracker since it's not yet destructed.
     _trim_tracker.stop();
     // Exclude trim time by increasing the start time.
     _start_time += _trim_time;
-    _phase_times->record_or_add_objcopy_time_secs(_worker_id, _trim_time.seconds());
+    _phase_times->record_or_add_time_secs(G1GCPhaseTimes::ObjCopy, _worker_id, _trim_time.seconds());
   }
 }