Merge

Author: JesperIRL

src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp

@@ -2055,6 +2055,15 @@ void ShenandoahHeap::op_weak_refs() {
  }
 }
 
+void ShenandoahHeap::stw_weak_refs(bool full_gc) {
+ // Weak refs processing
+ ShenandoahTimingsTracker t(full_gc ? ShenandoahPhaseTimings::full_gc_weakrefs_process
+ : ShenandoahPhaseTimings::degen_gc_weakrefs_process);
+ ShenandoahGCWorkerPhase worker_phase(full_gc ? ShenandoahPhaseTimings::full_gc_weakrefs_process
+ : ShenandoahPhaseTimings::degen_gc_weakrefs_process);
+ ref_processor()->process_references(workers(), false /* concurrent */);
+}
+
 void ShenandoahHeap::op_weak_roots() {
  if (is_concurrent_weak_root_in_progress()) {
  // Concurrent weak root processing
@@ -2194,12 +2203,6 @@ void ShenandoahHeap::op_degenerated(ShenandoahDegenPoint point) {
  ShenandoahCodeRoots::disarm_nmethods();
  }
 
- {
- ShenandoahTimingsTracker t(ShenandoahPhaseTimings::conc_weak_refs_work);
- ShenandoahGCWorkerPhase worker_phase(ShenandoahPhaseTimings::conc_weak_refs_work);
- ref_processor()->process_references(workers(), false /* concurrent */);
- }
-
  op_cleanup_early();
 
  case _degenerated_evac:
@@ -2485,6 +2488,7 @@ void ShenandoahHeap::stw_process_weak_roots(bool full_gc) {
 void ShenandoahHeap::parallel_cleaning(bool full_gc) {
  assert(SafepointSynchronize::is_at_safepoint(), "Must be at a safepoint");
  assert(is_stw_gc_in_progress(), "Only for Degenerated and Full GC");
+ stw_weak_refs(full_gc);
  stw_process_weak_roots(full_gc);
  stw_unload_classes(full_gc);
 }

src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp

@@ -515,6 +515,7 @@ class ShenandoahHeap : public CollectedHeap {
 private:
  void stw_unload_classes(bool full_gc);
  void stw_process_weak_roots(bool full_gc);
+ void stw_weak_refs(bool full_gc);
 
  // Prepare concurrent root processing
  void prepare_concurrent_roots();

src/hotspot/share/gc/shenandoah/shenandoahMarkCompact.cpp

@@ -249,7 +249,6 @@ void ShenandoahMarkCompact::phase1_mark_heap() {
  cm->mark_roots(ShenandoahPhaseTimings::full_gc_scan_roots);
  cm->finish_mark_from_roots(/* full_gc = */ true);
  heap->mark_complete_marking_context();
- rp->process_references(heap->workers(), false /* concurrent */);
  heap->parallel_cleaning(true /* full_gc */);
 }
 

src/hotspot/share/gc/shenandoah/shenandoahPhaseTimings.cpp

@@ -105,9 +105,11 @@ bool ShenandoahPhaseTimings::is_worker_phase(Phase phase) {
  case full_gc_adjust_roots:
  case degen_gc_scan_conc_roots:
  case degen_gc_update_roots:
+ case full_gc_weakrefs_process:
  case full_gc_scan_conc_roots:
  case full_gc_purge_class_unload:
  case full_gc_purge_weak_par:
+ case degen_gc_weakrefs_process:
  case degen_gc_purge_class_unload:
  case degen_gc_purge_weak_par:
  case heap_iteration_roots:

src/hotspot/share/gc/shenandoah/shenandoahPhaseTimings.hpp

@@ -118,6 +118,8 @@ class outputStream;
  f(degen_gc, "Pause Degenerated GC (N)") \
  f(degen_gc_scan_conc_roots, " Degen Mark Roots") \
  SHENANDOAH_PAR_PHASE_DO(degen_gc_conc_mark_, " DM: ", f) \
+ f(degen_gc_weakrefs, " Weak References") \
+ f(degen_gc_weakrefs_process, " Process") \
  f(degen_gc_purge, " System Purge") \
  f(degen_gc_purge_class_unload, " Unload Classes") \
  SHENANDOAH_PAR_PHASE_DO(degen_gc_purge_cu_par_, " DCU: ", f) \

src/hotspot/share/opto/block.cpp

@@ -1221,6 +1221,26 @@ void PhaseCFG::verify() const {
  if (j >= 1 && n->is_Mach() && n->as_Mach()->ideal_Opcode() == Op_CreateEx) {
  assert(j == 1 || block->get_node(j-1)->is_Phi(), "CreateEx must be first instruction in block");
  }
+ // Verify that memory-writing nodes (such as stores and calls) are placed
+ // in their original loop L (given by the control input) or in an ancestor
+ // of L. This is guaranteed by the freq. estimation model for reducible
+ // CFGs, and by special handling in PhaseCFG::schedule_late() otherwise.
+ if (n->is_Mach() && n->bottom_type()->has_memory() && n->in(0) != NULL) {
+ Block* original_block = find_block_for_node(n->in(0));
+ assert(original_block != NULL, "missing block for memory-writing node");
+ CFGLoop* original_or_ancestor = original_block->_loop;
+ assert(block->_loop != NULL && original_or_ancestor != NULL, "no loop");
+ bool found = false;
+ do {
+ if (block->_loop == original_or_ancestor) {
+ found = true;
+ break;
+ }
+ original_or_ancestor = original_or_ancestor->parent();
+ } while (original_or_ancestor != NULL);
+ assert(found, "memory-writing node is not placed in its original loop "
+ "or an ancestor of it");
+ }
  if (n->needs_anti_dependence_check()) {
  verify_anti_dependences(block, n);
  }

src/hotspot/share/opto/block.hpp

@@ -501,8 +501,8 @@ class PhaseCFG : public Phase {
  CFGLoop* create_loop_tree();
  bool is_dominator(Node* dom_node, Node* node);
  bool is_CFG(Node* n);
- bool is_control_proj_or_safepoint(Node* n);
- Block* find_block_for_node(Node* n);
+ bool is_control_proj_or_safepoint(Node* n) const;
+ Block* find_block_for_node(Node* n) const;
  bool is_dominating_control(Node* dom_ctrl, Node* n);
  #ifndef PRODUCT
  bool _trace_opto_pipelining; // tracing flag

src/hotspot/share/opto/gcm.cpp

@@ -152,14 +152,14 @@ bool PhaseCFG::is_CFG(Node* n) {
  return n->is_block_proj() || n->is_block_start() || is_control_proj_or_safepoint(n);
 }
 
-bool PhaseCFG::is_control_proj_or_safepoint(Node* n) {
+bool PhaseCFG::is_control_proj_or_safepoint(Node* n) const {
  bool result = (n->is_Mach() && n->as_Mach()->ideal_Opcode() == Op_SafePoint) || (n->is_Proj() && n->as_Proj()->bottom_type() == Type::CONTROL);
  assert(!result || (n->is_Mach() && n->as_Mach()->ideal_Opcode() == Op_SafePoint)
  || (n->is_Proj() && n->as_Proj()->_con == 0), "If control projection, it must be projection 0");
  return result;
 }
 
-Block* PhaseCFG::find_block_for_node(Node* n) {
+Block* PhaseCFG::find_block_for_node(Node* n) const {
  if (n->is_block_start() || n->is_block_proj()) {
  return get_block_for_node(n);
  } else {
@@ -1274,6 +1274,46 @@ void PhaseCFG::schedule_late(VectorSet &visited, Node_Stack &stack) {
  default:
  break;
  }
+ if (C->has_irreducible_loop() && self->bottom_type()->has_memory()) {
+ // If the CFG is irreducible, keep memory-writing nodes as close as
+ // possible to their original block (given by the control input). This
+ // prevents PhaseCFG::hoist_to_cheaper_block() from placing such nodes
+ // into descendants of their original loop, as in the following example:
+ //
+ // Original placement of store in B1 (loop L1):
+ //
+ // B1 (L1):
+ // m1 <- ..
+ // m2 <- store m1, ..
+ // B2 (L2):
+ // jump B2
+ // B3 (L1):
+ // .. <- .. m2, ..
+ //
+ // Wrong "hoisting" of store to B2 (in loop L2, child of L1):
+ //
+ // B1 (L1):
+ // m1 <- ..
+ // B2 (L2):
+ // m2 <- store m1, ..
+ // # Wrong: m1 and m2 interfere at this point.
+ // jump B2
+ // B3 (L1):
+ // .. <- .. m2, ..
+ //
+ // This "hoist inversion" can happen due to CFGLoop::compute_freq()'s
+ // inaccurate estimation of frequencies for irreducible CFGs, which can
+ // lead to for example assigning B1 and B3 a higher frequency than B2.
+#ifndef PRODUCT
+ if (trace_opto_pipelining()) {
+ tty->print_cr("# Irreducible loops: schedule in earliest block B%d:",
+ early->_pre_order);
+ self->dump();
+ }
+#endif
+ schedule_node_into_block(self, early);
+ continue;
+ }
  }
 
  // Gather LCA of all uses

src/hotspot/share/opto/macro.cpp

@@ -2562,11 +2562,8 @@ void PhaseMacroExpand::eliminate_macro_nodes() {
  bool progress = true;
  while (progress) {
  progress = false;
- for (int i = C->macro_count(); i > 0; i--) {
- if (i > C->macro_count()) {
- i = C->macro_count(); // more than 1 element can be eliminated at once
- }
- Node* n = C->macro_node(i-1);
+ for (int i = C->macro_count(); i > 0; i = MIN2(i - 1, C->macro_count())) { // more than 1 element can be eliminated at once
+ Node* n = C->macro_node(i - 1);
  bool success = false;
  DEBUG_ONLY(int old_macro_count = C->macro_count();)
  if (n->is_AbstractLock()) {
@@ -2581,11 +2578,8 @@ void PhaseMacroExpand::eliminate_macro_nodes() {
  progress = true;
  while (progress) {
  progress = false;
- for (int i = C->macro_count(); i > 0; i--) {
- if (i > C->macro_count()) {
- i = C->macro_count(); // more than 1 element can be eliminated at once
- }
- Node* n = C->macro_node(i-1);
+ for (int i = C->macro_count(); i > 0; i = MIN2(i - 1, C->macro_count())) { // more than 1 element can be eliminated at once
+ Node* n = C->macro_node(i - 1);
  bool success = false;
  DEBUG_ONLY(int old_macro_count = C->macro_count();)
  switch (n->class_id()) {

src/jdk.compiler/share/classes/com/sun/tools/doclint/DocLint.java

@@ -50,7 +50,7 @@ public abstract class DocLint implements Plugin {
 
  public static synchronized DocLint newDocLint() {
  if (docLintProvider == null) {
- docLintProvider = ServiceLoader.load(DocLint.class).stream()
+ docLintProvider = ServiceLoader.load(DocLint.class, ClassLoader.getSystemClassLoader()).stream()
  .filter(p_ -> p_.get().getName().equals("doclint"))
  .findFirst()
  .orElse(new ServiceLoader.Provider<>() {