jdk8-mips64-public/hotspot: comparison src/share/vm/opto/chaitin.cpp

-:34bd5e86aadb
+:8c83625e3a53
 return score + 1e10;        // Likely no progress to spill
 return score;
 }
-LRG_List::LRG_List( uint max ) : _cnt(max), _max(max), _lidxs(NEW_RESOURCE_ARRAY(uint,max)) {
-memset( _lidxs, 0, sizeof(uint)*max );
-}
-void LRG_List::extend( uint nidx, uint lidx ) {
-_nesting.check();
-if( nidx >= _max ) {
-uint size = 16;
-while( size <= nidx ) size <<=1;
-_lidxs = REALLOC_RESOURCE_ARRAY( uint, _lidxs, _max, size );
-_max = size;
-}
-while( _cnt <= nidx )
-_lidxs[_cnt++] = 0;
-_lidxs[nidx] = lidx;
-}
 #define NUMBUCKS 3
 // Straight out of Tarjan's union-find algorithm
 uint LiveRangeMap::find_compress(uint lrg) {
 uint cur = lrg;
-uint next = _uf_map[cur];
+uint next = _uf_map.at(cur);
 while (next != cur) { // Scan chain of equivalences
 assert( next < cur, "always union smaller");
 cur = next; // until find a fixed-point
-next = _uf_map[cur];
+next = _uf_map.at(cur);
 }
 // Core of union-find algorithm: update chain of
 // equivalences to be equal to the root.
 while (lrg != next) {
-uint tmp = _uf_map[lrg];
+uint tmp = _uf_map.at(lrg);
-_uf_map.map(lrg, next);
+_uf_map.at_put(lrg, next);
 lrg = tmp;
 }
 return lrg;
 }
 // Reset the Union-Find map to identity
 void LiveRangeMap::reset_uf_map(uint max_lrg_id) {
 _max_lrg_id= max_lrg_id;
 // Force the Union-Find mapping to be at least this large
-_uf_map.extend(_max_lrg_id, 0);
+_uf_map.at_put_grow(_max_lrg_id, 0);
 // Initialize it to be the ID mapping.
 for (uint i = 0; i < _max_lrg_id; ++i) {
-_uf_map.map(i, i);
+_uf_map.at_put(i, i);
 }
 }
 // Make all Nodes map directly to their final live range; no need for
 // the Union-Find mapping after this call.
 void LiveRangeMap::compress_uf_map_for_nodes() {
 // For all Nodes, compress mapping
-uint unique = _names.Size();
+uint unique = _names.length();
 for (uint i = 0; i < unique; ++i) {
-uint lrg = _names[i];
+uint lrg = _names.at(i);
 uint compressed_lrg = find(lrg);
 if (lrg != compressed_lrg) {
-_names.map(i, compressed_lrg);
+_names.at_put(i, compressed_lrg);
 }
 }
 }
 // Like Find above, but no path compress, so bad asymptotic behavior
 // brand new live ranges but have not told the allocator yet.
 if (lrg >= _max_lrg_id) {
 return lrg;
 }
-uint next = _uf_map[lrg];
+uint next = _uf_map.at(lrg);
 while (next != lrg) { // Scan chain of equivalences
 assert(next < lrg, "always union smaller");
 lrg = next; // until find a fixed-point
-next = _uf_map[lrg];
+next = _uf_map.at(lrg);
 }
 return next;
 }
 PhaseChaitin::PhaseChaitin(uint unique, PhaseCFG &cfg, Matcher &matcher)
 print_chaitin_statistics
 #else
 NULL
 #endif
 )
-, _lrg_map(unique)
+, _lrg_map(Thread::current()->resource_area(), unique)
 , _live(0)
 , _spilled_once(Thread::current()->resource_area())
 , _spilled_twice(Thread::current()->resource_area())
 , _lo_degree(0), _lo_stk_degree(0), _hi_degree(0), _simplified(0)
 , _oldphi(unique)
 // Pre-color to the zero live range, or pick virtual register
 const RegMask &rm = n->out_RegMask();
 _lrg_map.map(n->_idx, rm.is_NotEmpty() ? lr_counter++ : 0);
 }
 }
 // Reset the Union-Find mapping to be identity
 _lrg_map.reset_uf_map(lr_counter);
 }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/opto/chaitin.cpp

src/share/vm/opto/chaitin.cpp