8309204: Obsolete DoReserveCopyInSuperWord

Reviewed-by: kvn, thartmann

Author: eme64

src/hotspot/share/opto/c2_globals.hpp

@@ -341,9 +341,6 @@
   product(bool, UseCMoveUnconditionally, false,                             \
           "Use CMove (scalar and vector) ignoring profitability test.")     \
                                                                             \
-  product(bool, DoReserveCopyInSuperWord, true,                             \
-          "Create reserve copy of graph in SuperWord.")                     \
-                                                                            \
   notproduct(bool, TraceSuperWord, false,                                   \
           "Trace superword transforms")                                     \
                                                                             \

src/hotspot/share/opto/c2compiler.cpp

@@ -55,6 +55,9 @@ const char* C2Compiler::retry_no_iterative_escape_analysis() {
 const char* C2Compiler::retry_no_reduce_allocation_merges() {
   return "retry without reducing allocation merges";
 }
+const char* C2Compiler::retry_no_superword() {
+  return "retry without SuperWord";
+}
 
 void compiler_stubs_init(bool in_compiler_thread);
 
@@ -112,10 +115,18 @@ void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, boo
   bool do_reduce_allocation_merges = ReduceAllocationMerges && EliminateAllocations;
   bool eliminate_boxing = EliminateAutoBox;
   bool do_locks_coarsening = EliminateLocks;
+  bool do_superword = UseSuperWord;
 
   while (!env->failing()) {
     // Attempt to compile while subsuming loads into machine instructions.
-    Options options(subsume_loads, do_escape_analysis, do_iterative_escape_analysis, do_reduce_allocation_merges, eliminate_boxing, do_locks_coarsening, install_code);
+    Options options(subsume_loads,
+                    do_escape_analysis,
+                    do_iterative_escape_analysis,
+                    do_reduce_allocation_merges,
+                    eliminate_boxing,
+                    do_locks_coarsening,
+                    do_superword,
+                    install_code);
     Compile C(env, target, entry_bci, options, directive);
 
     // Check result and retry if appropriate.
@@ -150,6 +161,12 @@ void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, boo
         env->report_failure(C.failure_reason());
         continue;  // retry
       }
+      if (C.failure_reason_is(retry_no_superword())) {
+        assert(do_superword, "must make progress");
+        do_superword = false;
+        env->report_failure(C.failure_reason());
+        continue;  // retry
+      }
       if (C.has_boxed_value()) {
         // Recompile without boxing elimination regardless failure reason.
         assert(eliminate_boxing, "must make progress");

src/hotspot/share/opto/c2compiler.hpp

@@ -52,6 +52,7 @@ class C2Compiler : public AbstractCompiler {
   static const char* retry_no_iterative_escape_analysis();
   static const char* retry_no_reduce_allocation_merges();
   static const char* retry_no_locks_coarsening();
+  static const char* retry_no_superword();
 
   // Print compilation timers and statistics
   void print_timers();

src/hotspot/share/opto/compile.hpp

@@ -180,19 +180,24 @@ class Options {
   const bool _do_reduce_allocation_merges;  // Do try to reduce allocation merges.
   const bool _eliminate_boxing;      // Do boxing elimination.
   const bool _do_locks_coarsening;   // Do locks coarsening
+  const bool _do_superword;          // Do SuperWord
   const bool _install_code;          // Install the code that was compiled
  public:
-  Options(bool subsume_loads, bool do_escape_analysis,
+  Options(bool subsume_loads,
+          bool do_escape_analysis,
           bool do_iterative_escape_analysis,
           bool do_reduce_allocation_merges,
-          bool eliminate_boxing, bool do_locks_coarsening,
+          bool eliminate_boxing,
+          bool do_locks_coarsening,
+          bool do_superword,
           bool install_code) :
           _subsume_loads(subsume_loads),
           _do_escape_analysis(do_escape_analysis),
           _do_iterative_escape_analysis(do_iterative_escape_analysis),
           _do_reduce_allocation_merges(do_reduce_allocation_merges),
           _eliminate_boxing(eliminate_boxing),
           _do_locks_coarsening(do_locks_coarsening),
+          _do_superword(do_superword),
           _install_code(install_code) {
   }
 
@@ -204,6 +209,7 @@ class Options {
        /* do_reduce_allocation_merges = */ false,
        /* eliminate_boxing = */ false,
        /* do_lock_coarsening = */ false,
+       /* do_superword = */ true,
        /* install_code = */ true
     );
   }
@@ -578,6 +584,7 @@ class Compile : public Phase {
   bool              should_install_code() const { return _options._install_code; }
   /** Do locks coarsening. */
   bool              do_locks_coarsening() const { return _options._do_locks_coarsening; }
+  bool              do_superword() const        { return _options._do_superword; }
 
   // Other fixed compilation parameters.
   ciMethod*         method() const              { return _method; }

src/hotspot/share/opto/loopTransform.cpp

@@ -933,7 +933,8 @@ bool IdealLoopTree::policy_unroll(PhaseIdealLoop *phase) {
   //   the residual iterations are more than 10% of the trip count
   //   and rounds of "unroll,optimize" are not making significant progress
   //   Progress defined as current size less than 20% larger than previous size.
-  if (UseSuperWord && cl->node_count_before_unroll() > 0 &&
+  if (phase->C->do_superword() &&
+      cl->node_count_before_unroll() > 0 &&
       future_unroll_cnt > LoopUnrollMin &&
       is_residual_iters_large(future_unroll_cnt, cl) &&
       1.2 * cl->node_count_before_unroll() < (double)_body.size()) {
@@ -1038,7 +1039,7 @@ bool IdealLoopTree::policy_unroll(PhaseIdealLoop *phase) {
     } // switch
   }
 
-  if (UseSuperWord) {
+  if (phase->C->do_superword()) {
     // Only attempt slp analysis when user controls do not prohibit it
     if (!range_checks_present() && (LoopMaxUnroll > _local_loop_unroll_factor)) {
       // Once policy_slp_analysis succeeds, mark the loop with the

src/hotspot/share/opto/loopUnswitch.cpp

@@ -284,148 +284,3 @@ void PhaseIdealLoop::verify_fast_loop(LoopNode* head, const ProjNode* proj_true)
 }
 #endif // ASSERT
 
-LoopNode* PhaseIdealLoop::create_reserve_version_of_loop(IdealLoopTree *loop, CountedLoopReserveKit* lk) {
-  Node_List old_new;
-  LoopNode* head  = loop->_head->as_Loop();
-  Node*     entry = head->skip_strip_mined()->in(LoopNode::EntryControl);
-  _igvn.rehash_node_delayed(entry);
-  IdealLoopTree* outer_loop = head->is_strip_mined() ? loop->_parent->_parent : loop->_parent;
-
-  ConINode* const_1 = _igvn.intcon(1);
-  set_ctrl(const_1, C->root());
-  IfNode* iff = new IfNode(entry, const_1, PROB_MAX, COUNT_UNKNOWN);
-  register_node(iff, outer_loop, entry, dom_depth(entry));
-  ProjNode* iffast = new IfTrueNode(iff);
-  register_node(iffast, outer_loop, iff, dom_depth(iff));
-  ProjNode* ifslow = new IfFalseNode(iff);
-  register_node(ifslow, outer_loop, iff, dom_depth(iff));
-
-  // Clone the loop body.  The clone becomes the slow loop.  The
-  // original pre-header will (illegally) have 3 control users
-  // (old & new loops & new if).
-  clone_loop(loop, old_new, dom_depth(head), CloneIncludesStripMined, iff);
-  assert(old_new[head->_idx]->is_Loop(), "" );
-
-  LoopNode* slow_head = old_new[head->_idx]->as_Loop();
-
-#ifndef PRODUCT
-  if (TraceLoopOpts) {
-    tty->print_cr("PhaseIdealLoop::create_reserve_version_of_loop:");
-    tty->print("\t iff = %d, ", iff->_idx); iff->dump();
-    tty->print("\t iffast = %d, ", iffast->_idx); iffast->dump();
-    tty->print("\t ifslow = %d, ", ifslow->_idx); ifslow->dump();
-    tty->print("\t before replace_input_of: head = %d, ", head->_idx); head->dump();
-    tty->print("\t before replace_input_of: slow_head = %d, ", slow_head->_idx); slow_head->dump();
-  }
-#endif
-
-  // Fast (true) control
-  _igvn.replace_input_of(head->skip_strip_mined(), LoopNode::EntryControl, iffast);
-  // Slow (false) control
-  _igvn.replace_input_of(slow_head->skip_strip_mined(), LoopNode::EntryControl, ifslow);
-
-  recompute_dom_depth();
-
-  lk->set_iff(iff);
-
-#ifndef PRODUCT
-  if (TraceLoopOpts ) {
-    tty->print("\t after  replace_input_of: head = %d, ", head->_idx); head->dump();
-    tty->print("\t after  replace_input_of: slow_head = %d, ", slow_head->_idx); slow_head->dump();
-  }
-#endif
-
-  return slow_head->as_Loop();
-}
-
-CountedLoopReserveKit::CountedLoopReserveKit(PhaseIdealLoop* phase, IdealLoopTree *loop, bool active = true) :
-  _phase(phase),
-  _lpt(loop),
-  _lp(nullptr),
-  _iff(nullptr),
-  _lp_reserved(nullptr),
-  _has_reserved(false),
-  _use_new(false),
-  _active(active)
-  {
-    create_reserve();
-  };
-
-CountedLoopReserveKit::~CountedLoopReserveKit() {
-  if (!_active) {
-    return;
-  }
-
-  if (_has_reserved && !_use_new) {
-    // intcon(0)->iff-node reverts CF to the reserved copy
-    ConINode* const_0 = _phase->_igvn.intcon(0);
-    _phase->set_ctrl(const_0, _phase->C->root());
-    _iff->set_req(1, const_0);
-
-    #ifndef PRODUCT
-      if (TraceLoopOpts) {
-        tty->print_cr("CountedLoopReserveKit::~CountedLoopReserveKit()");
-        tty->print("\t discard loop %d and revert to the reserved loop clone %d: ", _lp->_idx, _lp_reserved->_idx);
-        _lp_reserved->dump();
-      }
-    #endif
-  }
-}
-
-bool CountedLoopReserveKit::create_reserve() {
-  if (!_active) {
-    return false;
-  }
-
-  if(!_lpt->_head->is_CountedLoop()) {
-    if (TraceLoopOpts) {
-      tty->print_cr("CountedLoopReserveKit::create_reserve: %d not counted loop", _lpt->_head->_idx);
-    }
-    return false;
-  }
-  CountedLoopNode *cl = _lpt->_head->as_CountedLoop();
-  if (!cl->is_valid_counted_loop(T_INT)) {
-    if (TraceLoopOpts) {
-      tty->print_cr("CountedLoopReserveKit::create_reserve: %d not valid counted loop", cl->_idx);
-    }
-    return false; // skip malformed counted loop
-  }
-  if (!cl->is_main_loop()) {
-    bool loop_not_canonical = true;
-    if (cl->is_post_loop() && (cl->slp_max_unroll() > 0)) {
-      loop_not_canonical = false;
-    }
-    // only reject some loop forms
-    if (loop_not_canonical) {
-      if (TraceLoopOpts) {
-        tty->print_cr("CountedLoopReserveKit::create_reserve: %d not canonical loop", cl->_idx);
-      }
-      return false; // skip normal, pre, and post (conditionally) loops
-    }
-  }
-
-  _lp = _lpt->_head->as_Loop();
-  _lp_reserved = _phase->create_reserve_version_of_loop(_lpt, this);
-
-  if (!_lp_reserved->is_CountedLoop()) {
-    return false;
-  }
-
-  Node* ifslow_pred = _lp_reserved->skip_strip_mined()->in(LoopNode::EntryControl);
-
-  if (!ifslow_pred->is_IfFalse()) {
-    return false;
-  }
-
-  Node* iff = ifslow_pred->in(0);
-  if (!iff->is_If() || iff != _iff) {
-    return false;
-  }
-
-  if (iff->in(1)->Opcode() != Op_ConI) {
-    return false;
-  }
-
-  _has_reserved = true;
-  return true;
-}

src/hotspot/share/opto/loopnode.cpp

@@ -4640,7 +4640,7 @@ void PhaseIdealLoop::build_and_optimize() {
   }
 
   // Convert scalar to superword operations at the end of all loop opts.
-  if (UseSuperWord && C->has_loops() && !C->major_progress()) {
+  if (C->do_superword() && C->has_loops() && !C->major_progress()) {
     // SuperWord transform
     SuperWord sw(this);
     for (LoopTreeIterator iter(_ltree_root); !iter.done(); iter.next()) {
@@ -5359,11 +5359,12 @@ int PhaseIdealLoop::build_loop_tree_impl( Node *n, int pre_order ) {
         if( !n->is_CallStaticJava() || !n->as_CallStaticJava()->_name ) {
           Node *iff = n->in(0)->in(0);
           // No any calls for vectorized loops.
-          if( UseSuperWord || !iff->is_If() ||
-              (n->in(0)->Opcode() == Op_IfFalse &&
-               (1.0 - iff->as_If()->_prob) >= 0.01) ||
-              (iff->as_If()->_prob >= 0.01) )
+          if (C->do_superword() ||
+              !iff->is_If() ||
+              (n->in(0)->Opcode() == Op_IfFalse && (1.0 - iff->as_If()->_prob) >= 0.01) ||
+              iff->as_If()->_prob >= 0.01) {
             innermost->_has_call = 1;
+          }
         }
       } else if( n->is_Allocate() && n->as_Allocate()->_is_scalar_replaceable ) {
         // Disable loop optimizations if the loop has a scalar replaceable