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

equal deleted inserted replaced

-:351229eec596
+:512b2c76e3b7
 // These are chosen immediately. Some instructions are required to immediately
 // precede the last instruction in the block, and these are taken last. Of the
 // remaining cases (most), choose the instruction with the greatest latency
 // (that is, the most number of pseudo-cycles required to the end of the
 // routine). If there is a tie, choose the instruction with the most inputs.
-Node *Block::select(PhaseCFG *cfg, Node_List &worklist, int *ready_cnt, VectorSet &next_call, uint sched_slot) {
+Node *Block::select(PhaseCFG *cfg, Node_List &worklist, GrowableArray<int> &ready_cnt, VectorSet &next_call, uint sched_slot) {
 // If only a single entry on the stack, use it
 uint cnt = worklist.size();
 if (cnt == 1) {
 Node *n = worklist[0];
 break;
 }
 // More than this instruction pending for successor to be ready,
 // don't choose this if other opportunities are ready
-if (ready_cnt[use->_idx] > 1)
+if (ready_cnt.at(use->_idx) > 1)
 n_choice = 1;
 }
 // loop terminated, prefer not to use this instruction
 if (found_machif)
 }
 }
 //------------------------------sched_call-------------------------------------
-uint Block::sched_call( Matcher &matcher, Block_Array &bbs, uint node_cnt, Node_List &worklist, int *ready_cnt, MachCallNode *mcall, VectorSet &next_call ) {
+uint Block::sched_call( Matcher &matcher, Block_Array &bbs, uint node_cnt, Node_List &worklist, GrowableArray<int> &ready_cnt, MachCallNode *mcall, VectorSet &next_call ) {
 RegMask regs;
 // Schedule all the users of the call right now.  All the users are
 // projection Nodes, so they must be scheduled next to the call.
 // Collect all the defined registers.
 for (DUIterator_Fast imax, i = mcall->fast_outs(imax); i < imax; i++) {
 Node* n = mcall->fast_out(i);
 assert( n->is_MachProj(), "" );
---ready_cnt[n->_idx];
+int n_cnt = ready_cnt.at(n->_idx)-1;
-assert( !ready_cnt[n->_idx], "" );
+ready_cnt.at_put(n->_idx, n_cnt);
+assert( n_cnt == 0, "" );
 // Schedule next to call
 _nodes.map(node_cnt++, n);
 // Collect defined registers
 regs.OR(n->out_RegMask());
 // Check for scheduling the next control-definer
 // Children of projections are now all ready
 for (DUIterator_Fast jmax, j = n->fast_outs(jmax); j < jmax; j++) {
 Node* m = n->fast_out(j); // Get user
 if( bbs[m->_idx] != this ) continue;
 if( m->is_Phi() ) continue;
-if( !--ready_cnt[m->_idx] )
+int m_cnt = ready_cnt.at(m->_idx)-1;
+ready_cnt.at_put(m->_idx, m_cnt);
+if( m_cnt == 0 )
 worklist.push(m);
 }
 }
 }
 //------------------------------schedule_local---------------------------------
 // Topological sort within a block.  Someday become a real scheduler.
-bool Block::schedule_local(PhaseCFG *cfg, Matcher &matcher, int *ready_cnt, VectorSet &next_call) {
+bool Block::schedule_local(PhaseCFG *cfg, Matcher &matcher, GrowableArray<int> &ready_cnt, VectorSet &next_call) {
 // Already "sorted" are the block start Node (as the first entry), and
 // the block-ending Node and any trailing control projections.  We leave
 // these alone.  PhiNodes and ParmNodes are made to follow the block start
 // Node.  Everything else gets topo-sorted.
 for( uint j=0; j<cnt; j++ ) {
 Node *m = n->in(j);
 if( m && cfg->_bbs[m->_idx] == this && !m->is_top() )
 local++;              // One more block-local input
 }
-ready_cnt[n->_idx] = local; // Count em up
+ready_cnt.at_put(n->_idx, local); // Count em up
 #ifdef ASSERT
 if( UseConcMarkSweepGC || UseG1GC ) {
 if( n->is_Mach() && n->as_Mach()->ideal_Opcode() == Op_StoreCM ) {
 // Check the precedence edges
 n->add_prec(x);
 }
 }
 }
 for(uint i2=i; i2<_nodes.size(); i2++ ) // Trailing guys get zapped count
-ready_cnt[_nodes[i2]->_idx] = 0;
+ready_cnt.at_put(_nodes[i2]->_idx, 0);
 // All the prescheduled guys do not hold back internal nodes
 uint i3;
 for(i3 = 0; i3<phi_cnt; i3++ ) {  // For all pre-scheduled
 Node *n = _nodes[i3];       // Get pre-scheduled
 for (DUIterator_Fast jmax, j = n->fast_outs(jmax); j < jmax; j++) {
 Node* m = n->fast_out(j);
-if( cfg->_bbs[m->_idx] ==this ) // Local-block user
+if( cfg->_bbs[m->_idx] ==this ) { // Local-block user
-ready_cnt[m->_idx]--;   // Fix ready count
+int m_cnt = ready_cnt.at(m->_idx)-1;
+ready_cnt.at_put(m->_idx, m_cnt);   // Fix ready count
+}
 }
 }
 Node_List delay;
 // Make a worklist
 Node_List worklist;
 for(uint i4=i3; i4<node_cnt; i4++ ) {    // Put ready guys on worklist
 Node *m = _nodes[i4];
-if( !ready_cnt[m->_idx] ) {   // Zero ready count?
+if( !ready_cnt.at(m->_idx) ) {   // Zero ready count?
 if (m->is_iteratively_computed()) {
 // Push induction variable increments last to allow other uses
 // of the phi to be scheduled first. The select() method breaks
 // ties in scheduling by worklist order.
 delay.push(m);
 #ifndef PRODUCT
 if (cfg->trace_opto_pipelining()) {
 for (uint j=0; j<_nodes.size(); j++) {
 Node     *n = _nodes[j];
 int     idx = n->_idx;
-tty->print("#   ready cnt:%3d  ", ready_cnt[idx]);
+tty->print("#   ready cnt:%3d  ", ready_cnt.at(idx));
 tty->print("latency:%3d  ", cfg->_node_latency->at_grow(idx));
 tty->print("%4d: %s\n", idx, n->Name());
 }
 }
 #endif
-uint max_idx = matcher.C->unique();
+uint max_idx = (uint)ready_cnt.length();
 // Pull from worklist and schedule
 while( worklist.size() ) {    // Worklist is not ready
 #ifndef PRODUCT
 if (cfg->trace_opto_pipelining()) {
 // Children are now all ready
 for (DUIterator_Fast i5max, i5 = n->fast_outs(i5max); i5 < i5max; i5++) {
 Node* m = n->fast_out(i5); // Get user
 if( cfg->_bbs[m->_idx] != this ) continue;
 if( m->is_Phi() ) continue;
-if (m->_idx > max_idx) { // new node, skip it
+if (m->_idx >= max_idx) { // new node, skip it
 assert(m->is_MachProj() && n->is_Mach() && n->as_Mach()->has_call(), "unexpected node types");
 continue;
 }
-if( !--ready_cnt[m->_idx] )
+int m_cnt = ready_cnt.at(m->_idx)-1;
+ready_cnt.at_put(m->_idx, m_cnt);
+if( m_cnt == 0 )
 worklist.push(m);
 }
 }
 if( phi_cnt != end_idx() ) {

changeset 11567	512b2c76e3b7
parent 11196	a310a659c580
child 13104	657b387034fb