#define DBG_WORKSET 128
DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
-/* factor to weight the different costs of reloading/rematerializing a node
- (see bespill.h be_get_reload_costs_no_weight) */
-#define RELOAD_COST_FACTOR 10
-
#define TIME_UNDEFINED 6666
-#define PLACE_SPILLS
+//#define LOOK_AT_LOOPDEPTH
/**
* An association between a node and a point in time.
static spill_env_t *senv; /**< see bespill.h */
static pdeq *worklist;
+static bool move_spills = true;
+static bool respectloopdepth = true;
+static bool improve_known_preds = true;
+/* factor to weight the different costs of reloading/rematerializing a node
+ (see bespill.h be_get_reload_costs_no_weight) */
+static int remat_bonus = 10;
+
+static const lc_opt_table_entry_t options[] = {
+ LC_OPT_ENT_BOOL ("movespills", "try to move spills out of loops", &move_spills),
+ LC_OPT_ENT_BOOL ("respectloopdepth", "exprimental (outermost loop cutting)", &respectloopdepth),
+ LC_OPT_ENT_BOOL ("improveknownpreds", "experimental (known preds cutting)", &improve_known_preds),
+ LC_OPT_ENT_INT ("rematbonus", "give bonus to rematerialisable nodes", &remat_bonus),
+ LC_OPT_LAST
+};
+
static int loc_compare(const void *a, const void *b)
{
const loc_t *p = a;
assert(! (flags & arch_irn_flags_ignore));
use = be_get_next_use(uses, from, from_step, def, skip_from_uses);
- if(USES_IS_INFINITE(use.time))
+ if (USES_IS_INFINITE(use.time))
return USES_INFINITY;
/* We have to keep nonspillable nodes in the workingset */
- if(flags & arch_irn_flags_dont_spill)
+ if (flags & arch_irn_flags_dont_spill)
return 0;
- costs = be_get_reload_costs_no_weight(senv, def, use.before);
- assert(costs * RELOAD_COST_FACTOR < 1000);
- time = use.time + 1000 - (costs * RELOAD_COST_FACTOR);
+ /* give some bonus to rematerialisable nodes */
+ if (remat_bonus > 0) {
+ costs = be_get_reload_costs_no_weight(senv, def, use.before);
+ assert(costs * remat_bonus < 1000);
+ time = use.time + 1000 - (costs * remat_bonus);
+ }
return time;
}
/* Only make more free room if we do not have enough */
if (spills_needed > 0) {
-#ifndef PLACE_SPILLS
- ir_node *curr_bb = get_nodes_block(instr);
- workset_t *ws_start = get_block_info(curr_bb)->start_workset;
-#endif
+ ir_node *curr_bb = NULL;
+ workset_t *ws_start = NULL;
+
+ if (move_spills) {
+ curr_bb = get_nodes_block(instr);
+ ws_start = get_block_info(curr_bb)->start_workset;
+ }
DB((dbg, DBG_DECIDE, " disposing %d values\n", spills_needed));
DB((dbg, DBG_DECIDE, " disposing node %+F (%u)\n", val,
workset_get_time(ws, i)));
-#ifdef PLACE_SPILLS
- if(!USES_IS_INFINITE(ws->vals[i].time) && !ws->vals[i].spilled) {
- ir_node *after_pos = sched_prev(instr);
- be_add_spill(senv, val, after_pos);
- }
-#endif
-
-#ifndef PLACE_SPILLS
- /* Logic for not needed live-ins: If a value is disposed
- * before its first use, remove it from start workset
- * We don't do this for phis though */
- if (!is_Phi(val) && ! ir_nodeset_contains(&used, val)) {
- workset_remove(ws_start, val);
- DB((dbg, DBG_DECIDE, " (and removing %+F from start workset)\n", val));
+ if (move_spills) {
+ if (!USES_IS_INFINITE(ws->vals[i].time)
+ && !ws->vals[i].spilled) {
+ ir_node *after_pos = sched_prev(instr);
+ DB((dbg, DBG_DECIDE, "Spill %+F after node %+F\n", val,
+ after_pos));
+ be_add_spill(senv, val, after_pos);
+ }
+ } else {
+ /* Logic for not needed live-ins: If a value is disposed
+ * before its first use, remove it from start workset
+ * We don't do this for phis though */
+ if (!is_Phi(val) && ! ir_nodeset_contains(&used, val)) {
+ workset_remove(ws_start, val);
+ DB((dbg, DBG_DECIDE, " (and removing %+F from start workset)\n", val));
+ }
}
-#endif
}
/* kill the last 'demand' entries in the array */
}
}
+enum {
+ AVAILABLE_EVERYWHERE,
+ AVAILABLE_NOWHERE,
+ AVAILABLE_PARTLY,
+ AVAILABLE_UNKNOWN
+};
+
+static unsigned available_in_all_preds(workset_t* const* pred_worksets,
+ size_t n_pred_worksets,
+ const ir_node *value, bool is_local_phi)
+{
+ size_t i;
+ bool avail_everywhere = true;
+ bool avail_nowhere = true;
+
+ assert(n_pred_worksets > 0);
+
+ /* value available in all preds? */
+ for (i = 0; i < n_pred_worksets; ++i) {
+ bool found = false;
+ const workset_t *p_workset = pred_worksets[i];
+ int p_len = workset_get_length(p_workset);
+ int p_i;
+ const ir_node *l_value;
+
+ if (is_local_phi) {
+ assert(is_Phi(value));
+ l_value = get_irn_n(value, i);
+ } else {
+ l_value = value;
+ }
+
+ for (p_i = 0; p_i < p_len; ++p_i) {
+ const loc_t *p_l = &p_workset->vals[p_i];
+ if (p_l->node != l_value)
+ continue;
+
+ found = true;
+ break;
+ }
+
+ if (found) {
+ avail_nowhere = false;
+ } else {
+ avail_everywhere = false;
+ }
+ }
+
+ if (avail_everywhere) {
+ assert(!avail_nowhere);
+ return AVAILABLE_EVERYWHERE;
+ } else if (avail_nowhere) {
+ return AVAILABLE_NOWHERE;
+ } else {
+ return AVAILABLE_PARTLY;
+ }
+}
+
/** Decides whether a specific node should be in the start workset or not
*
* @param env belady environment
* @param loop the loop of the node
*/
static loc_t to_take_or_not_to_take(ir_node* first, ir_node *node,
- ir_loop *loop)
+ ir_loop *loop, unsigned available)
{
be_next_use_t next_use;
loc_t loc;
}
/* We have to keep nonspillable nodes in the workingset */
- if(arch_irn_get_flags(arch_env, node) & arch_irn_flags_dont_spill) {
+ if (arch_irn_get_flags(arch_env, node) & arch_irn_flags_dont_spill) {
loc.time = 0;
DB((dbg, DBG_START, " %+F taken (dontspill node)\n", node, loc.time));
return loc;
}
next_use = be_get_next_use(uses, first, 0, node, 0);
- if(USES_IS_INFINITE(next_use.time)) {
+ if (USES_IS_INFINITE(next_use.time)) {
// the nodes marked as live in shouldn't be dead, so it must be a phi
assert(is_Phi(node));
loc.time = USES_INFINITY;
DB((dbg, DBG_START, " %+F not taken (dead)\n", node));
- if(is_Phi(node)) {
- be_spill_phi(senv, node);
- }
return loc;
}
loc.time = next_use.time;
- if(next_use.outermost_loop >= get_loop_depth(loop)) {
+ if (improve_known_preds) {
+ if (available == AVAILABLE_EVERYWHERE) {
+ DB((dbg, DBG_START, " %+F taken (%u, live in all preds)\n",
+ node, loc.time));
+ return loc;
+ } else if(available == AVAILABLE_NOWHERE) {
+ DB((dbg, DBG_START, " %+F not taken (%u, live in no pred)\n",
+ node, loc.time));
+ loc.time = USES_INFINITY;
+ return loc;
+ }
+ }
+
+ if (!respectloopdepth || next_use.outermost_loop >= get_loop_depth(loop)) {
DB((dbg, DBG_START, " %+F taken (%u, loop %d)\n", node, loc.time,
next_use.outermost_loop));
} else {
DB((dbg, DBG_START, " %+F delayed (outerdepth %d < loopdepth %d)\n",
node, next_use.outermost_loop, get_loop_depth(loop)));
}
+
return loc;
}
unsigned pressure;
int arity;
workset_t **pred_worksets;
+ bool all_preds_known;
+
+ /* check predecessors */
+ arity = get_irn_arity(block);
+ pred_worksets = alloca(sizeof(pred_worksets[0]) * arity);
+ all_preds_known = true;
+ for(i = 0; i < arity; ++i) {
+ ir_node *pred_block = get_Block_cfgpred_block(block, i);
+ block_info_t *pred_info = get_block_info(pred_block);
+
+ if (pred_info == NULL) {
+ pred_worksets[i] = NULL;
+ all_preds_known = false;
+ } else {
+ pred_worksets[i] = pred_info->end_workset;
+ }
+ }
/* Collect all values living at start of block */
starters = NEW_ARR_F(loc_t, 0);
/* check all Phis first */
sched_foreach(block, node) {
+ unsigned available;
+
if (! is_Phi(node))
break;
+ if (!arch_irn_consider_in_reg_alloc(arch_env, cls, node))
+ continue;
- loc = to_take_or_not_to_take(first, node, loop);
+ if (all_preds_known) {
+ available = available_in_all_preds(pred_worksets, arity, node, true);
+ } else {
+ available = AVAILABLE_UNKNOWN;
+ }
+
+ loc = to_take_or_not_to_take(first, node, loop, available);
if (! USES_IS_INFINITE(loc.time)) {
if (USES_IS_PENDING(loc.time))
ARR_APP1(loc_t, delayed, loc);
else
ARR_APP1(loc_t, starters, loc);
+ } else {
+ be_spill_phi(senv, node);
}
}
/* check all Live-Ins */
be_lv_foreach(lv, block, be_lv_state_in, i) {
ir_node *node = be_lv_get_irn(lv, block, i);
+ unsigned available;
+
+ if (all_preds_known) {
+ available = available_in_all_preds(pred_worksets, arity, node, false);
+ } else {
+ available = AVAILABLE_UNKNOWN;
+ }
- loc = to_take_or_not_to_take(first, node, loop);
+ loc = to_take_or_not_to_take(first, node, loop, available);
if (! USES_IS_INFINITE(loc.time)) {
if (USES_IS_PENDING(loc.time))
/* so far we only put nodes into the starters list that are used inside
* the loop. If register pressure in the loop is low then we can take some
* values and let them live through the loop */
+ DB((dbg, DBG_START, "Loop pressure %d, taking %d delayed vals\n",
+ pressure, free_slots));
if (free_slots > 0) {
qsort(delayed, ARR_LEN(delayed), sizeof(delayed[0]), loc_compare);
- for (i = 0; i < ARR_LEN(delayed) && i < free_slots; ++i) {
+ for (i = 0; i < ARR_LEN(delayed) && free_slots > 0; ++i) {
int p, arity;
loc_t *loc = & delayed[i];
DB((dbg, DBG_START, " delayed %+F taken\n", loc->node));
ARR_APP1(loc_t, starters, *loc);
loc->node = NULL;
+ --free_slots;
skip_delayed:
;
}
* but not in the start workset */
for (i = ARR_LEN(delayed) - 1; i >= 0; --i) {
ir_node *node = delayed[i].node;
- if(node == NULL || !is_Phi(node) || get_nodes_block(node) != block)
+ if (node == NULL || !is_Phi(node) || get_nodes_block(node) != block)
continue;
DB((dbg, DBG_START, " spilling delayed phi %+F\n", node));
/* determine spill status of the values: If there's 1 pred block (which
* is no backedge) where the value is spilled then we must set it to
* spilled here. */
- arity = get_irn_arity(block);
- pred_worksets = alloca(sizeof(pred_worksets[0]) * arity);
- for(i = 0; i < arity; ++i) {
- ir_node *pred_block = get_Block_cfgpred_block(block, i);
- block_info_t *pred_info = get_block_info(pred_block);
-
- if(pred_info == NULL)
- pred_worksets[i] = NULL;
- else
- pred_worksets[i] = pred_info->end_workset;
- }
-
for(i = 0; i < ws_count; ++i) {
loc_t *loc = &ws->vals[i];
ir_node *value = loc->node;
int n;
/* phis from this block aren't spilled */
- if(get_nodes_block(value) == block) {
+ if (get_nodes_block(value) == block) {
assert(is_Phi(value));
loc->spilled = false;
continue;
}
}
-#if 0
-static void decide_start_workset2(const ir_node *block)
-{
- int arity;
- workset_t **pred_worksets;
- int p;
- int len;
-
- /* check if all predecessors are known */
- arity = get_irn_arity(block);
- pred_worksets = alloca(sizeof(pred_worksets[0]) * arity);
- for (i = 0; i < arity; ++i) {
- ir_node *pred_block = get_Block_cfgpred_block(block, i);
- block_info_t *pred_info = get_block_info(pred_block);
-
- if (pred_info == NULL) {
- /* not all predecessors known, use decide_start_workset */
- decide_start_workset(block);
- return;
- }
-
- pred_worksets[i] = pred_info->end_workset;
- }
-
- /* take values live in all pred blocks */
- len = workset_get_length(pred_workset[0]);
- for (p = 0; p < p_len; ++p) {
- const loc_t *l = &pred_workset[0]->vals[p];
- ir_node *value;
- bool spilled = false;
-
- if (USES_IS_INFINITE(l->time))
- continue;
-
- /* value available in all preds? */
- value = l->node;
- for (i = 0; i < arity; ++i) {
- bool found = false;
- workset_t p_workset = &pred_worksets[i];
- int p_len = workset_get_length(p_workset);
- int p_i;
-
- for (p_i = 0; p_i < p_len; ++p_i) {
- const loc_t *p_l = &p_workset->vals[p_i];
- if (p_l->node != value)
- continue;
-
- found = true;
- if (p_l->spilled)
- spilled = true;
- break;
- }
-
- if (!found)
- break;
- }
-
- /* it was available in all preds, TODO: insert spills... */
- if (i >= arity) {
- workset_insert(ws, value, spilled);
- }
- }
-
-
- /* Copy the best ones from starters to start workset */
- ws_count = MIN(ARR_LEN(starters), n_regs);
- workset_clear(ws);
- workset_bulk_fill(ws, ws_count, starters);
-}
-
-#endif
-
/**
* For the given block @p block, decide for each values
* whether it is used from a register or is reloaded
const ir_edge_t *edge;
/* no need to process a block twice */
- if(get_block_info(block) != NULL) {
+ if (get_block_info(block) != NULL) {
return;
}
ir_node *pred_block = get_Block_cfgpred_block(block, i);
block_info_t *pred_info = get_block_info(pred_block);
- if(pred_info == NULL) {
+ if (pred_info == NULL) {
/* process predecessor first (it will be in the queue already) */
- if(!is_backedge(block, i)) {
+ if (!is_backedge(block, i)) {
return;
}
has_backedges = 1;
}
}
(void) has_backedges;
- if(arity == 0) {
+ if (arity == 0) {
workset_clear(ws);
- } else if(arity == 1) {
+ } else if (arity == 1) {
ir_node *pred_block = get_Block_cfgpred_block(block, 0);
block_info_t *pred_info = get_block_info(pred_block);
int iter2;
bool found = false;
workset_foreach(start_workset, n2, iter2) {
- if(n2 == node) {
+ if (n2 == node) {
found = true;
break;
}
if (found)
continue;
-#ifdef PLACE_SPILLS
- if(be_is_live_in(lv, block, node)
+ if (move_spills && be_is_live_in(lv, block, node)
&& !pred_end_workset->vals[iter].spilled) {
ir_node *insert_point;
if (arity > 1) {
insert_point));
be_add_spill(senv, node, insert_point);
}
-#endif
}
/* reload missing values in predecessors, add missing spills */
/* if node is a phi of the current block we reload
* the corresponding argument, else node itself */
- if(is_Phi(node) && get_nodes_block(node) == block) {
+ if (is_Phi(node) && get_nodes_block(node) == block) {
node = get_irn_n(node, i);
assert(!l->spilled);
/* we might have unknowns as argument for the phi */
- if(!arch_irn_consider_in_reg_alloc(arch_env, cls, node))
+ if (!arch_irn_consider_in_reg_alloc(arch_env, cls, node))
continue;
}
/* check if node is in a register at end of pred */
pred_loc = workset_contains(pred_end_workset, node);
if (pred_loc != NULL) {
-#ifdef PLACE_SPILLS
/* we might have to spill value on this path */
- if (!pred_loc->spilled && l->spilled) {
+ if (move_spills && !pred_loc->spilled && l->spilled) {
ir_node *insert_point
= be_get_end_of_block_insertion_point(pred);
insert_point = sched_prev(insert_point);
insert_point));
be_add_spill(senv, node, insert_point);
}
-#endif
} else {
/* node is not in register at the end of pred -> reload it */
DB((dbg, DBG_FIX, " reload %+F\n", node));
be_liveness_assure_sets(be_assure_liveness(birg));
/* construct control flow loop tree */
- if(! (get_irg_loopinfo_state(irg) & loopinfo_cf_consistent)) {
+ if (! (get_irg_loopinfo_state(irg) & loopinfo_cf_consistent)) {
construct_cf_backedges(irg);
}
static be_spiller_t belady_spiller = {
be_spill_belady
};
+ lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
+ lc_opt_entry_t *belady_group = lc_opt_get_grp(be_grp, "belady");
+ lc_opt_add_table(belady_group, options);
be_register_spiller("belady", &belady_spiller);
FIRM_DBG_REGISTER(dbg, "firm.be.spill.belady");