graal-compiler: src/share/vm/opto/chaitin.hpp comparison

comparison src/share/vm/opto/chaitin.hpp @ 14478:bb9356ec5967

Merge

author	hseigel
date	Sun, 23 Feb 2014 13:16:03 -0500
parents	c84312468f5c
children	99fc8c086679

comparison

equal deleted inserted replaced

-:96d2c94bbdd0
+:bb9356ec5967
 _eff_degree += mod;
 assert(!_mask.is_AllStack() || (_mask.is_AllStack() && lo_degree()), "_eff_degree can't be bigger than AllStack_size - _num_regs if the mask supports stack registers");
 }
 // Compute the degree between 2 live ranges
 int compute_degree( LRG &l ) const;
+bool mask_is_nonempty_and_up() const {
+return mask().is_UP() && mask_size();
+}
+bool is_float_or_vector() const {
+return _is_float || _is_vector;
+}
 private:
 RegMask _mask;                // Allowed registers for this LRG
 uint _mask_size;              // cache of _mask.Size();
 public:
 void set_mask( const RegMask &rm ) { _mask = rm; debug_only(_msize_valid=0;)}
 void AND( const RegMask &rm ) { _mask.AND(rm); debug_only(_msize_valid=0;)}
 void SUBTRACT( const RegMask &rm ) { _mask.SUBTRACT(rm); debug_only(_msize_valid=0;)}
 void Clear()   { _mask.Clear()  ; debug_only(_msize_valid=1); _mask_size = 0; }
 void Set_All() { _mask.Set_All(); debug_only(_msize_valid=1); _mask_size = RegMask::CHUNK_SIZE; }
 void Insert( OptoReg::Name reg ) { _mask.Insert(reg);  debug_only(_msize_valid=0;) }
 void Remove( OptoReg::Name reg ) { _mask.Remove(reg);  debug_only(_msize_valid=0;) }
 void clear_to_pairs() { _mask.clear_to_pairs(); debug_only(_msize_valid=0;) }
 void clear_to_sets()  { _mask.clear_to_sets(_num_regs); debug_only(_msize_valid=0;) }
 // Add edge between reg and everything in the vector.
 // Same as _ifg->add_vector(reg,live) EXCEPT use the RegMask
 // information to trim the set of interferences.  Return the
 // count of edges added.
-void interfere_with_live( uint reg, IndexSet *live );
+void interfere_with_live(uint lid, IndexSet* liveout);
+#ifdef ASSERT
 // Count register pressure for asserts
-uint count_int_pressure( IndexSet *liveout );
+uint count_int_pressure(IndexSet* liveout);
-uint count_float_pressure( IndexSet *liveout );
+uint count_float_pressure(IndexSet* liveout);
+#endif
 // Build the interference graph using virtual registers only.
 // Used for aggressive coalescing.
 void build_ifg_virtual( );
+class Pressure {
+public:
+// keeps track of the register pressure at the current
+// instruction (used when stepping backwards in the block)
+uint _current_pressure;
+// keeps track of the instruction index of the first low to high register pressure
+// transition (starting from the top) in the block
+// if high_pressure_index == 0 then the whole block is high pressure
+// if high_pressure_index = b.end_idx() + 1 then the whole block is low pressure
+uint _high_pressure_index;
+// stores the highest pressure we find
+uint _final_pressure;
+// number of live ranges that constitute high register pressure
+const uint _high_pressure_limit;
+// lower the register pressure and look for a low to high pressure
+// transition
+void lower(LRG& lrg, uint& location) {
+_current_pressure -= lrg.reg_pressure();
+if (_current_pressure == _high_pressure_limit) {
+_high_pressure_index = location;
+if (_current_pressure > _final_pressure) {
+_final_pressure = _current_pressure + 1;
+}
+}
+}
+// raise the pressure and store the pressure if it's the biggest
+// pressure so far
+void raise(LRG &lrg) {
+_current_pressure += lrg.reg_pressure();
+if (_current_pressure > _final_pressure) {
+_final_pressure = _current_pressure;
+}
+}
+Pressure(uint high_pressure_index, uint high_pressure_limit)
+: _current_pressure(0)
+, _high_pressure_index(high_pressure_index)
+, _high_pressure_limit(high_pressure_limit)
+, _final_pressure(0) {}
+};
+void lower_pressure(Block* b, uint location, LRG& lrg, IndexSet* liveout, Pressure& int_pressure, Pressure& float_pressure);
+void raise_pressure(Block* b, LRG& lrg, Pressure& int_pressure, Pressure& float_pressure);
+void check_for_high_pressure_transition_at_fatproj(uint& block_reg_pressure, uint location, LRG& lrg, Pressure& pressure, const int op_regtype);
+void add_input_to_liveout(Block* b, Node* n, IndexSet* liveout, double cost, Pressure& int_pressure, Pressure& float_pressure);
+void compute_initial_block_pressure(Block* b, IndexSet* liveout, Pressure& int_pressure, Pressure& float_pressure, double cost);
+bool remove_node_if_not_used(Block* b, uint location, Node* n, uint lid, IndexSet* liveout);
+void assign_high_score_to_immediate_copies(Block* b, Node* n, LRG& lrg, uint next_inst, uint last_inst);
+void remove_interference_from_copy(Block* b, uint location, uint lid_copy, IndexSet* liveout, double cost, Pressure& int_pressure, Pressure& float_pressure);
+void remove_bound_register_from_interfering_live_ranges(LRG& lrg, IndexSet* liveout, uint& must_spill);
+void check_for_high_pressure_block(Pressure& pressure);
+void adjust_high_pressure_index(Block* b, uint& hrp_index, Pressure& pressure);
 // Build the interference graph using physical registers when available.
 // That is, if 2 live ranges are simultaneously alive but in their
 // acceptable register sets do not overlap, then they do not interfere.
 uint build_ifg_physical( ResourceArea *a );
 void post_allocate_copy_removal();
 Node *skip_copies( Node *c );
 // Replace the old node with the current live version of that value
 // and yank the old value if it's dead.
 int replace_and_yank_if_dead( Node *old, OptoReg::Name nreg,
 Block *current_block, Node_List& value, Node_List& regnd ) {
 Node* v = regnd[nreg];
 assert(v->outcnt() != 0, "no dead values");
 old->replace_by(v);
 return yank_if_dead(old, current_block, &value, &regnd);
 }
 int yank_if_dead( Node *old, Block *current_block, Node_List *value, Node_List *regnd ) {
 return yank_if_dead_recurse(old, old, current_block, value, regnd);
 }
 int yank_if_dead_recurse(Node *old, Node *orig_old, Block *current_block,
 Node_List *value, Node_List *regnd);
 int yank( Node *old, Block *current_block, Node_List *value, Node_List *regnd );
 int elide_copy( Node *n, int k, Block *current_block, Node_List &value, Node_List &regnd, bool can_change_regs );
 int use_prior_register( Node *copy, uint idx, Node *def, Block *current_block, Node_List &value, Node_List &regnd );
 bool may_be_copy_of_callee( Node *def ) const;
 // If nreg already contains the same constant as val then eliminate it
 bool eliminate_copy_of_constant(Node* val, Node* n,
 Block *current_block, Node_List& value, Node_List &regnd,
 OptoReg::Name nreg, OptoReg::Name nreg2);
 // Extend the node to LRG mapping
 void add_reference( const Node *node, const Node *old_node);
 private:

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/chaitin.hpp @ 14478:bb9356ec5967