jdk-sandbox: comparison hotspot/src/share/vm/opto/superword.cpp

equal deleted inserted replaced

-:01bb07d23a5b
+:4db2fb26dc49
 // If a max vector exists which is not larger than _local_loop_unroll_factor
 // stop looking, we already have the max vector to map to.
 if (cur_max_vector < local_loop_unroll_factor) {
 is_slp = false;
-NOT_PRODUCT(if (TraceSuperWordLoopUnrollAnalysis) tty->print_cr("slp analysis fails: unroll limit greater than max vector\n"));
+if (TraceSuperWordLoopUnrollAnalysis) {
+tty->print_cr("slp analysis fails: unroll limit greater than max vector\n");
+}
 break;
 }
 // Map the maximal common vector
 if (VectorNode::implemented(n->Opcode(), cur_max_vector, bt)) {
 extend_packlist();
 if (_do_vector_loop) {
 if (_packset.length() == 0) {
-#ifndef PRODUCT
 if (TraceSuperWord) {
 tty->print_cr("\nSuperWord::_do_vector_loop DFA could not build packset, now trying to build anyway");
 }
-#endif
 pack_parallel();
 }
 }
 combine_packs();
 assert(!same_velt_type(s, mem_ref), "sanity");
 memops.push(s);
 }
 best_align_to_mem_ref = find_align_to_ref(memops);
 if (best_align_to_mem_ref == NULL) {
-NOT_PRODUCT(if (TraceSuperWord) tty->print_cr("SuperWord::find_adjacent_refs(): best_align_to_mem_ref == NULL");)
+if (TraceSuperWord) {
+tty->print_cr("SuperWord::find_adjacent_refs(): best_align_to_mem_ref == NULL");
+}
 break;
 }
 best_iv_adjustment = get_iv_adjustment(best_align_to_mem_ref);
 NOT_PRODUCT(find_adjacent_refs_trace_1(best_align_to_mem_ref, best_iv_adjustment);)
 // Restore list.
 }
 } // while (memops.size() != 0
 set_align_to_ref(best_align_to_mem_ref);
-#ifndef PRODUCT
 if (TraceSuperWord) {
 tty->print_cr("\nAfter find_adjacent_refs");
 print_packset();
 }
-#endif
 }
 #ifndef PRODUCT
 void SuperWord::find_adjacent_refs_trace_1(Node* best_align_to_mem_ref, int best_iv_adjustment) {
 if (is_trace_adjacent()) {
 }
 if (sink_dependent) {
 _dg.make_edge(s1, slice_sink);
 }
 }
-#ifndef PRODUCT
 if (TraceSuperWord) {
 tty->print_cr("\nDependence graph for slice: %d", n->_idx);
 for (int q = 0; q < _nlist.length(); q++) {
 _dg.print(_nlist.at(q));
 }
 tty->cr();
 }
-#endif
 _nlist.clear();
 }
-#ifndef PRODUCT
 if (TraceSuperWord) {
 tty->print_cr("\ndisjoint_ptrs: %s", _disjoint_ptrs.length() > 0 ? "" : "NONE");
 for (int r = 0; r < _disjoint_ptrs.length(); r++) {
 _disjoint_ptrs.at(r).print();
 tty->cr();
 }
 tty->cr();
 }
-#endif
 }
 //---------------------------mem_slice_preds---------------------------
 // Return a memory slice (node list) in predecessor order starting at "start"
 void SuperWord::mem_slice_preds(Node* start, Node* stop, GrowableArray<Node*> &preds) {
 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
 Node* out = n->fast_out(i);
 if (out->is_Load()) {
 if (in_bb(out)) {
 preds.push(out);
-NOT_PRODUCT(if (TraceSuperWord && Verbose) tty->print_cr("SuperWord::mem_slice_preds: added pred(%d)", out->_idx);)
+if (TraceSuperWord && Verbose) {
+tty->print_cr("SuperWord::mem_slice_preds: added pred(%d)", out->_idx);
+}
 }
 } else {
 // FIXME
 if (out->is_MergeMem() && !in_bb(out)) {
 // Either unrolling is causing a memory edge not to disappear,
 }
 }//else
 }//for
 if (n == stop) break;
 preds.push(n);
-NOT_PRODUCT(if (TraceSuperWord && Verbose) tty->print_cr("SuperWord::mem_slice_preds: added pred(%d)", n->_idx);)
+if (TraceSuperWord && Verbose) {
+tty->print_cr("SuperWord::mem_slice_preds: added pred(%d)", n->_idx);
+}
 prev = n;
 assert(n->is_Mem(), "unexpected node %s", n->Name());
 n = n->in(MemNode::Memory);
 }
 }
 Node_List* p = _packset.at(i);
 order_def_uses(p);
 }
 }
-#ifndef PRODUCT
 if (TraceSuperWord) {
 tty->print_cr("\nAfter extend_packlist");
 print_packset();
 }
-#endif
 }
 //------------------------------follow_use_defs---------------------------
 // Extend the packset by visiting operand definitions of nodes in pack p
 bool SuperWord::follow_use_defs(Node_List* p) {
 if (p1 == NULL) {
 _packset.remove_at(i);
 }
 }
-#ifndef PRODUCT
 if (TraceSuperWord) {
 tty->print_cr("\nAfter combine_packs");
 print_packset();
 }
-#endif
 }
 //-----------------------------construct_my_pack_map--------------------------
 // Construct the map from nodes to packs.  Only valid after the
 // point where a node is only in one pack (after combine_packs).
 if (SuperWordLoopUnrollAnalysis) {
 if (cl->has_passed_slp()) {
 uint slp_max_unroll_factor = cl->slp_max_unroll();
 if (slp_max_unroll_factor == max_vlen) {
-NOT_PRODUCT(if (TraceSuperWordLoopUnrollAnalysis) tty->print_cr("vector loop(unroll=%d, len=%d)\n", max_vlen, max_vlen_in_bytes*BitsPerByte));
+if (TraceSuperWordLoopUnrollAnalysis) {
+tty->print_cr("vector loop(unroll=%d, len=%d)\n", max_vlen, max_vlen_in_bytes*BitsPerByte);
+}
 // For atomic unrolled loops which are vector mapped, instigate more unrolling.
 cl->set_notpassed_slp();
 // if vector resources are limited, do not allow additional unrolling
 if (FLOATPRESSURE > 8) {
 C->set_major_progress();
 }
 }
 }
 ct++;
 } while (again);
-#ifndef PRODUCT
-if (TraceSuperWord && Verbose)
+if (TraceSuperWord && Verbose) {
 tty->print_cr("compute_max_depth iterated: %d times", ct);
-#endif
+}
 }
 //-------------------------compute_vector_element_type-----------------------
 // Compute necessary vector element type for expressions
 // This propagates backwards a narrower integer type when the
 // upper bits of the value are not needed.
 // Example:  char a,b,c;  a = b + c;
 // Normally the type of the add is integer, but for packed character
 // operations the type of the add needs to be char.
 void SuperWord::compute_vector_element_type() {
-#ifndef PRODUCT
+if (TraceSuperWord && Verbose) {
-if (TraceSuperWord && Verbose)
 tty->print_cr("\ncompute_velt_type:");
-#endif
+}
 // Initial type
 for (int i = 0; i < _block.length(); i++) {
 Node* n = _block.at(i);
 set_velt_type(n, container_type(n));
 }
 int offset  = p.offset_in_bytes();
 offset     += iv_adjust*p.memory_size();
 int off_rem = offset % vw;
 int off_mod = off_rem >= 0 ? off_rem : off_rem + vw;
-NOT_PRODUCT(if(TraceSuperWord && Verbose) tty->print_cr("SWPointer::memory_alignment: off_rem = %d, off_mod = %d", off_rem, off_mod);)
+if (TraceSuperWord && Verbose) {
+tty->print_cr("SWPointer::memory_alignment: off_rem = %d, off_mod = %d", off_rem, off_mod);
+}
 return off_mod;
 }
 //---------------------------container_type---------------------------
 // Smallest type containing range of values
 }
 }//for (DUIterator_Fast imax,
 }//for (int i...
 if (_ii_first == -1 || _ii_last == -1) {
-#ifndef PRODUCT
 if (TraceSuperWord && Verbose) {
 tty->print_cr("SuperWord::mark_generations unknown error, something vent wrong");
 }
-#endif
 return -1; // something vent wrong
 }
 // collect nodes in the first and last generations
 assert(_iteration_first.length() == 0, "_iteration_first must be empty");
 assert(_iteration_last.length() == 0, "_iteration_last must be empty");
 break;
 }
 }//for
 if (found == false) {
-#ifndef PRODUCT
 if (TraceSuperWord && Verbose) {
 tty->print_cr("SuperWord::mark_generations: Cannot build order of iterations - no dependent Store for %d", nd->_idx);
 }
-#endif
 _ii_order.clear();
 return -1;
 }
 } //while
 _ii_order.push(_clone_map.gen(nd->_idx));
 }
 #endif
 return true;
 }
-#ifndef PRODUCT
 if (TraceSuperWord && Verbose) {
 tty->print_cr("SuperWord::fix_commutative_inputs: cannot fix node %d", fix->_idx);
 }
-#endif
 return false;
 }
 bool SuperWord::pack_parallel() {
 #ifndef PRODUCT
 #endif
 for (int i = 0; i < _mem_slice_head.length(); i++) {
 Node* n = _mem_slice_head.at(i);
 if ( !in_bb(n) || !n->is_Phi() || n->bottom_type() != Type::MEMORY) {
-#ifndef PRODUCT
 if (TraceSuperWord && Verbose) {
 tty->print_cr("SuperWord::hoist_loads_in_graph: skipping unexpected node n=%d", n->_idx);
 }
-#endif
 continue;
 }
 #ifndef PRODUCT
 if (_vector_loop_debug) {
 }
 }//for
 restart(); // invalidate all basic structures, since we rebuilt the graph
-#ifndef PRODUCT
 if (TraceSuperWord && Verbose) {
 tty->print_cr("\nSuperWord::hoist_loads_in_graph() the graph was rebuilt, all structures invalidated and need rebuild");
 }
-#endif
 return true;
 }

changeset 34174	4db2fb26dc49
parent 34168	dbdc6907b55d
child 34185	ee71c590a456