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

equal deleted inserted replaced

-:355f4f42dda5
+:95a99e617f28
 // Convert triangular matrix to square matrix
 void PhaseIFG::SquareUp() {
 assert( !_is_square, "only on triangular" );
 // Simple transpose
-for( uint i = 0; i < _maxlrg; i++ ) {
+for(uint i = 0; i < _maxlrg; i++ ) {
-IndexSetIterator elements(&_adjs[i]);
+if (!_adjs[i].is_empty()) {
-uint datum;
+IndexSetIterator elements(&_adjs[i]);
-while ((datum = elements.next()) != 0) {
+uint datum;
-_adjs[datum].insert( i );
+while ((datum = elements.next()) != 0) {
+_adjs[datum].insert(i);
+}
 }
 }
 _is_square = true;
 }
 //return _adjs[a].unordered_member(b);
 return _adjs[a].member(b);
 }
 // Union edges of B into A
-void PhaseIFG::Union( uint a, uint b ) {
+void PhaseIFG::Union(uint a, uint b) {
 assert( _is_square, "only on square" );
 IndexSet *A = &_adjs[a];
-IndexSetIterator b_elements(&_adjs[b]);
+if (!_adjs[b].is_empty()) {
-uint datum;
+IndexSetIterator b_elements(&_adjs[b]);
-while ((datum = b_elements.next()) != 0) {
+uint datum;
-if(A->insert(datum)) {
+while ((datum = b_elements.next()) != 0) {
-_adjs[datum].insert(a);
+if (A->insert(datum)) {
-lrgs(a).invalid_degree();
+_adjs[datum].insert(a);
-lrgs(datum).invalid_degree();
+lrgs(a).invalid_degree();
+lrgs(datum).invalid_degree();
+}
 }
 }
 }
 // Yank a Node and all connected edges from the IFG.  Return a
 assert( _is_square, "only on square" );
 assert( !_yanked->test(a), "" );
 _yanked->set(a);
 // I remove the LRG from all neighbors.
-IndexSetIterator elements(&_adjs[a]);
 LRG &lrg_a = lrgs(a);
-uint datum;
-while ((datum = elements.next()) != 0) {
+if (!_adjs[a].is_empty()) {
-_adjs[datum].remove(a);
+IndexSetIterator elements(&_adjs[a]);
-lrgs(datum).inc_degree( -lrg_a.compute_degree(lrgs(datum)) );
+uint datum;
+while ((datum = elements.next()) != 0) {
+_adjs[datum].remove(a);
+lrgs(datum).inc_degree(-lrg_a.compute_degree(lrgs(datum)));
+}
 }
 return neighbors(a);
 }
 // Re-insert a yanked Node.
 void PhaseIFG::re_insert(uint a) {
 assert( _is_square, "only on square" );
 assert( _yanked->test(a), "" );
 _yanked->remove(a);
+if (_adjs[a].is_empty()) return;
 IndexSetIterator elements(&_adjs[a]);
 uint datum;
 while ((datum = elements.next()) != 0) {
 _adjs[datum].insert(a);
 lrgs(datum).invalid_degree();
 // Compute the degree between 2 live ranges.  If both live ranges are
 // aligned-adjacent powers-of-2 then we use the MAX size.  If either is
 // mis-aligned (or for Fat-Projections, not-adjacent) then we have to
 // MULTIPLY the sizes.  Inspect Brigg's thesis on register pairs to see why
 // this is so.
-int LRG::compute_degree( LRG &l ) const {
+int LRG::compute_degree(LRG &l) const {
 int tmp;
 int num_regs = _num_regs;
 int nregs = l.num_regs();
 tmp =  (_fat_proj || l._fat_proj)     // either is a fat-proj?
 ? (num_regs * nregs)                // then use product
 // Compute effective degree for this live range.  If both live ranges are
 // aligned-adjacent powers-of-2 then we use the MAX size.  If either is
 // mis-aligned (or for Fat-Projections, not-adjacent) then we have to
 // MULTIPLY the sizes.  Inspect Brigg's thesis on register pairs to see why
 // this is so.
-int PhaseIFG::effective_degree( uint lidx ) const {
+int PhaseIFG::effective_degree(uint lidx) const {
+IndexSet *s = neighbors(lidx);
+if (s->is_empty()) return 0;
 int eff = 0;
 int num_regs = lrgs(lidx).num_regs();
 int fat_proj = lrgs(lidx)._fat_proj;
-IndexSet *s = neighbors(lidx);
 IndexSetIterator elements(s);
 uint nidx;
-while((nidx = elements.next()) != 0) {
+while ((nidx = elements.next()) != 0) {
 LRG &lrgn = lrgs(nidx);
 int nregs = lrgn.num_regs();
 eff += (fat_proj || lrgn._fat_proj) // either is a fat-proj?
 ? (num_regs * nregs)              // then use product
 : MAX2(num_regs,nregs);           // else use max
 #ifndef PRODUCT
 void PhaseIFG::dump() const {
 tty->print_cr("-- Interference Graph --%s--",
 _is_square ? "square" : "triangular" );
-if( _is_square ) {
+if (_is_square) {
-for( uint i = 0; i < _maxlrg; i++ ) {
+for (uint i = 0; i < _maxlrg; i++) {
 tty->print(_yanked->test(i) ? "XX " : "  ");
 tty->print("L%d: { ",i);
-IndexSetIterator elements(&_adjs[i]);
+if (!_adjs[i].is_empty()) {
-uint datum;
+IndexSetIterator elements(&_adjs[i]);
-while ((datum = elements.next()) != 0) {
+uint datum;
-tty->print("L%d ", datum);
+while ((datum = elements.next()) != 0) {
+tty->print("L%d ", datum);
+}
 }
 tty->print_cr("}");
 }
 return;
 for( j = _maxlrg; j > i; j-- )
 if( test_edge(j - 1,i) ) {
 tty->print("L%d ",j - 1);
 }
 tty->print("| ");
-IndexSetIterator elements(&_adjs[i]);
+if (!_adjs[i].is_empty()) {
-uint datum;
+IndexSetIterator elements(&_adjs[i]);
-while ((datum = elements.next()) != 0) {
+uint datum;
-tty->print("L%d ", datum);
+while ((datum = elements.next()) != 0) {
+tty->print("L%d ", datum);
+}
 }
 tty->print("}\n");
 }
 tty->print("\n");
 }
 void PhaseIFG::verify( const PhaseChaitin *pc ) const {
 // IFG is square, sorted and no need for Find
 for( uint i = 0; i < _maxlrg; i++ ) {
 assert(!_yanked->test(i) || !neighbor_cnt(i), "Is removed completely" );
 IndexSet *set = &_adjs[i];
-IndexSetIterator elements(set);
+if (!set->is_empty()) {
-uint idx;
+IndexSetIterator elements(set);
-uint last = 0;
+uint idx;
-while ((idx = elements.next()) != 0) {
+uint last = 0;
-assert(idx != i, "Must have empty diagonal");
+while ((idx = elements.next()) != 0) {
-assert(pc->_lrg_map.find_const(idx) == idx, "Must not need Find");
+assert(idx != i, "Must have empty diagonal");
-assert(_adjs[idx].member(i), "IFG not square");
+assert(pc->_lrg_map.find_const(idx) == idx, "Must not need Find");
-assert(!_yanked->test(idx), "No yanked neighbors");
+assert(_adjs[idx].member(i), "IFG not square");
-assert(last < idx, "not sorted increasing");
+assert(!_yanked->test(idx), "No yanked neighbors");
-last = idx;
+assert(last < idx, "not sorted increasing");
+last = idx;
+}
 }
 assert(!lrgs(i)._degree_valid || effective_degree(i) == lrgs(i).degree(), "degree is valid but wrong");
 }
 }
 #endif
 * Interfere this register with everything currently live.
 * Check for interference by checking overlap of regmasks.
 * Only interfere if acceptable register masks overlap.
 */
 void PhaseChaitin::interfere_with_live(uint lid, IndexSet* liveout) {
-LRG& lrg = lrgs(lid);
+if (!liveout->is_empty()) {
-const RegMask& rm = lrg.mask();
+LRG& lrg = lrgs(lid);
-IndexSetIterator elements(liveout);
+const RegMask &rm = lrg.mask();
-uint interfering_lid = elements.next();
+IndexSetIterator elements(liveout);
-while (interfering_lid != 0) {
+uint interfering_lid = elements.next();
-LRG& interfering_lrg = lrgs(interfering_lid);
+while (interfering_lid != 0) {
-if (rm.overlap(interfering_lrg.mask())) {
+LRG& interfering_lrg = lrgs(interfering_lid);
-_ifg->add_edge(lid, interfering_lid);
+if (rm.overlap(interfering_lrg.mask())) {
-}
+_ifg->add_edge(lid, interfering_lid);
-interfering_lid = elements.next();
+}
+interfering_lid = elements.next();
+}
 }
 }
 // Actually build the interference graph.  Uses virtual registers only, no
 // physical register masks.  This allows me to be very aggressive when
 } // End of forall blocks
 }
 #ifdef ASSERT
 uint PhaseChaitin::count_int_pressure(IndexSet* liveout) {
+if (liveout->is_empty()) {
+return 0;
+}
 IndexSetIterator elements(liveout);
 uint lidx = elements.next();
 uint cnt = 0;
 while (lidx != 0) {
 LRG& lrg = lrgs(lidx);
 }
 return cnt;
 }
 uint PhaseChaitin::count_float_pressure(IndexSet* liveout) {
+if (liveout->is_empty()) {
+return 0;
+}
 IndexSetIterator elements(liveout);
 uint lidx = elements.next();
 uint cnt = 0;
 while (lidx != 0) {
 LRG& lrg = lrgs(lidx);
 * We add the cost for the whole block to the area of the live ranges initially.
 * If a live range gets killed in the block, we'll subtract the unused part of
 * the block from the area.
 */
 void PhaseChaitin::compute_initial_block_pressure(Block* b, IndexSet* liveout, Pressure& int_pressure, Pressure& float_pressure, double cost) {
-IndexSetIterator elements(liveout);
+if (!liveout->is_empty()) {
-uint lid = elements.next();
+IndexSetIterator elements(liveout);
-while (lid != 0) {
+uint lid = elements.next();
-LRG& lrg = lrgs(lid);
+while (lid != 0) {
-lrg._area += cost;
+LRG &lrg = lrgs(lid);
-raise_pressure(b, lrg, int_pressure, float_pressure);
+lrg._area += cost;
-lid = elements.next();
+raise_pressure(b, lrg, int_pressure, float_pressure);
+lid = elements.next();
+}
 }
 assert(int_pressure.current_pressure() == count_int_pressure(liveout), "the int pressure is incorrect");
 assert(float_pressure.current_pressure() == count_float_pressure(liveout), "the float pressure is incorrect");
 }
 * Computes the entry register pressure of a block, looking at all live
 * ranges in the livein. The register pressure is computed for both float
 * and int/pointer registers.
 */
 void PhaseChaitin::compute_entry_block_pressure(Block* b) {
-IndexSet* livein = _live->livein(b);
+IndexSet *livein = _live->livein(b);
-IndexSetIterator elements(livein);
+if (!livein->is_empty()) {
-uint lid = elements.next();
+IndexSetIterator elements(livein);
-while (lid != 0) {
+uint lid = elements.next();
-LRG& lrg = lrgs(lid);
+while (lid != 0) {
-raise_pressure(b, lrg, _sched_int_pressure, _sched_float_pressure);
+LRG &lrg = lrgs(lid);
-lid = elements.next();
+raise_pressure(b, lrg, _sched_int_pressure, _sched_float_pressure);
+lid = elements.next();
+}
 }
 // Now check phis for locally defined inputs
 for (uint j = 0; j < b->number_of_nodes(); j++) {
 Node* n = b->get_node(j);
 if (n->is_Phi()) {
 * Computes the exit register pressure of a block, looking at all live
 * ranges in the liveout. The register pressure is computed for both float
 * and int/pointer registers.
 */
 void PhaseChaitin::compute_exit_block_pressure(Block* b) {
 IndexSet* livein = _live->live(b);
-IndexSetIterator elements(livein);
 _sched_int_pressure.set_current_pressure(0);
 _sched_float_pressure.set_current_pressure(0);
-uint lid = elements.next();
+if (!livein->is_empty()) {
-while (lid != 0) {
+IndexSetIterator elements(livein);
-LRG& lrg = lrgs(lid);
+uint lid = elements.next();
-raise_pressure(b, lrg, _sched_int_pressure, _sched_float_pressure);
+while (lid != 0) {
-lid = elements.next();
+LRG &lrg = lrgs(lid);
+raise_pressure(b, lrg, _sched_int_pressure, _sched_float_pressure);
+lid = elements.next();
+}
 }
 }
 /*
 * Remove dead node if it's not used.
 /*
 * The defined value must go in a particular register. Remove that register from
 * all conflicting parties and avoid the interference.
 */
 void PhaseChaitin::remove_bound_register_from_interfering_live_ranges(LRG& lrg, IndexSet* liveout, uint& must_spill) {
+if (liveout->is_empty()) return;
 // Check for common case
 const RegMask& rm = lrg.mask();
 int r_size = lrg.num_regs();
 // Smear odd bits
 IndexSetIterator elements(liveout);
 for (uint location = last_inst; location > 0; location--) {
 Node* n = block->get_node(location);
 uint lid = _lrg_map.live_range_id(n);
-if(lid) {
+if (lid) {
 LRG& lrg = lrgs(lid);
 // A DEF normally costs block frequency; rematerialized values are
 // removed from the DEF sight, so LOWER costs here.
 lrg._cost += n->rematerialize() ? 0 : block->_freq;

changeset 59081	95a99e617f28
parent 58962	2dcfc28a314d