#include "raw_bitset.h"
#include "irphase_t.h"
#include "pqueue.h"
-#include "pset_new.h"
#include "xmalloc.h"
#include "pdeq.h"
+#include "pset.h"
#include "irprintf.h"
+#include "irbitset.h"
+#include "error.h"
+#include "list.h"
+
#include "irbitset.h"
#include "bearch.h"
#include "becopyopt_t.h"
#include "bemodule.h"
-DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
#define COL_COST_INFEASIBLE DBL_MAX
#define AFF_NEIGHBOUR_FIX_BENEFIT 128.0
#define NEIGHBOUR_CONSTR_COSTS 64.0
-#define DBG_AFF_CHUNK(env, level, chunk) DEBUG_ONLY(do { if (firm_dbg_get_mask(dbg) & (level)) dbg_aff_chunk((env), (chunk)); } while(0))
-#define DBG_COL_COST(env, level, cost) DEBUG_ONLY(do { if (firm_dbg_get_mask(dbg) & (level)) dbg_col_cost((env), (cost)); } while(0))
+
+#ifdef DEBUG_libfirm
+
+#define DBG_AFF_CHUNK(env, level, chunk) do { if (firm_dbg_get_mask(dbg) & (level)) dbg_aff_chunk((env), (chunk)); } while(0)
+#define DBG_COL_COST(env, level, cost) do { if (firm_dbg_get_mask(dbg) & (level)) dbg_col_cost((env), (cost)); } while(0)
+
+static firm_dbg_module_t *dbg = NULL;
+
+#else
+
+#define DBG_AFF_CHUNK(env, level, chunk)
+#define DBG_COL_COST(env, level, cost)
+
+#endif
static int last_chunk_id = 0;
+static int recolor_limit = 4;
typedef struct _col_cost_t {
int col;
* An affinity chunk.
*/
typedef struct _aff_chunk_t {
- bitset_t *nodes; /**< A bitset containing all nodes inside this chunk. */
- int weight; /**< Weight of this chunk */
- unsigned weight_consistent : 1; /**< Set if the weight is consistent. */
- int id; /**< For debugging: An id of this chunk. */
+ ir_node **n; /**< An ARR_F containing all nodes of the chunk. */
+ bitset_t *nodes; /**< A bitset containing all nodes inside this chunk. */
+ bitset_t *interfere; /**< A bitset containing all interfering neighbours of the nodes in this chunk. */
+ int weight; /**< Weight of this chunk */
+ unsigned weight_consistent : 1; /**< Set if the weight is consistent. */
+ unsigned deleted : 1; /**< Set if the was deleted. */
+ int id; /**< For debugging: An id of this chunk. */
+ col_cost_t *color_affinity;
} aff_chunk_t;
/**
int n_regs; /**< number of regs in class */
int k; /**< number of non-ignore registers in class */
bitset_t *ignore_regs; /**< set containing all global ignore registers */
- int *map_regs; /**< map the available colors to the available registers */
ir_phase ph; /**< phase object holding data for nodes */
pqueue *chunks; /**< priority queue for chunks */
- pset_new_t chunkset; /**< set holding all chunks */
+ pset *chunkset; /**< set holding all chunks */
be_ifg_t *ifg; /**< the interference graph */
const arch_env_t *aenv; /**< the arch environment */
copy_opt_t *co; /**< the copy opt object */
/* stores coalescing related information for a node */
typedef struct _co_mst_irn_t {
- ir_node *irn; /**< the irn this information belongs to */
- aff_chunk_t *chunk; /**< the chunk this irn belongs to */
- bitset_t *adm_colors; /**< set of admissible colors for this irn */
- ir_node **int_neighs; /**< array of all interfering neighbours (cached for speed reasons) */
- int n_neighs; /**< length of the interfering neighbours array. */
- int int_aff_neigh; /**< number of interfering affinity neighbours */
- int col; /**< color currently assigned */
- int init_col; /**< the initial color */
- int tmp_col; /**< a temporary assigned color */
- unsigned fixed : 1; /**< the color is fixed */
- unsigned tmp_fixed : 1; /**< the color is temporary fixed */
+ ir_node *irn; /**< the irn this information belongs to */
+ aff_chunk_t *chunk; /**< the chunk this irn belongs to */
+ bitset_t *adm_colors; /**< set of admissible colors for this irn */
+ ir_node **int_neighs; /**< array of all interfering neighbours (cached for speed reasons) */
+ int n_neighs; /**< length of the interfering neighbours array. */
+ int int_aff_neigh; /**< number of interfering affinity neighbours */
+ int col; /**< color currently assigned */
+ int init_col; /**< the initial color */
+ int tmp_col; /**< a temporary assigned color */
+ unsigned fixed : 1; /**< the color is fixed */
+ struct list_head list; /**< Queue for coloring undo. */
+ double constr_factor;
} co_mst_irn_t;
#define get_co_mst_irn(mst_env, irn) (phase_get_or_set_irn_data(&(mst_env)->ph, (irn)))
* Write a chunk to stderr for debugging.
*/
static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c) {
- int idx;
+ bitset_pos_t idx;
if (c->weight_consistent)
ir_fprintf(stderr, " $%d ", c->weight);
ir_fprintf(stderr, "{");
* Dump all admissible colors to stderr.
*/
static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node) {
- int idx;
+ bitset_pos_t idx;
+ (void) env;
+
if (bitset_popcnt(node->adm_colors) < 1)
fprintf(stderr, "no admissible colors?!?");
else {
#endif /* DEBUG_libfirm */
static INLINE int get_mst_irn_col(const co_mst_irn_t *node) {
- return node->tmp_fixed ? node->tmp_col : node->col;
+ return node->tmp_col >= 0 ? node->tmp_col : node->col;
}
/**
* Always returns true.
*/
static int decider_always_yes(const co_mst_irn_t *node, int col) {
+ (void) node;
+ (void) col;
return 1;
}
static int cmp_col_cost(const void *a, const void *b) {
const col_cost_t *c1 = a;
const col_cost_t *c2 = b;
-
- return c1->cost < c2->cost ? -1 : 1;
+ double diff = c1->cost - c2->cost;
+ return (diff > 0) - (diff < 0);
}
/**
aff_chunk_t *c = xmalloc(sizeof(*c));
c->weight = -1;
c->weight_consistent = 0;
+ c->n = NEW_ARR_F(ir_node *, 0);
c->nodes = bitset_irg_malloc(env->co->irg);
+ c->interfere = bitset_irg_malloc(env->co->irg);
+ c->color_affinity = xmalloc(env->k * sizeof(c->color_affinity[0]));
c->id = last_chunk_id++;
- pset_new_insert(&env->chunkset, c);
+ pset_insert(env->chunkset, c, c->id);
return c;
}
* Frees all memory allocated by an affinity chunk.
*/
static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
- pset_new_remove(&env->chunkset, c);
+ pset_remove(env->chunkset, c, c->id);
bitset_free(c->nodes);
+ bitset_free(c->interfere);
+ xfree(c->color_affinity);
+ DEL_ARR_F(c->n);
+ c->deleted = 1;
free(c);
}
* Adds a node to an affinity chunk
*/
static INLINE void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
+ int i;
+
+ if (bitset_is_set(c->nodes, get_irn_idx(node->irn)))
+ return;
+
c->weight_consistent = 0;
node->chunk = c;
bitset_set(c->nodes, get_irn_idx(node->irn));
+
+ ARR_APP1(ir_node *, c->n, node->irn);
+
+ for (i = node->n_neighs - 1; i >= 0; --i) {
+ ir_node *neigh = node->int_neighs[i];
+ bitset_set(c->interfere, get_irn_idx(neigh));
+ }
}
/**
res->irn = irn;
res->chunk = NULL;
res->fixed = 0;
- res->tmp_fixed = 0;
res->tmp_col = -1;
res->int_neighs = NULL;
res->int_aff_neigh = 0;
res->col = arch_register_get_index(arch_get_irn_register(env->aenv, irn));
res->init_col = res->col;
+ INIT_LIST_HEAD(&res->list);
DB((dbg, LEVEL_4, "Creating phase info for %+F\n", irn));
/* Exclude colors not assignable to the irn */
req = arch_get_register_req(env->aenv, irn, -1);
- if (arch_register_req_is(req, limited))
+ if (arch_register_req_is(req, limited)) {
rbitset_copy_to_bitset(req->limited, res->adm_colors);
+ res->constr_factor = 1.0 - (double) bitset_popcnt(res->adm_colors) / env->k;
+ }
else
bitset_set_all(res->adm_colors);
/* build list of interfering neighbours */
len = 0;
be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
- obstack_ptr_grow(phase_obst(ph), neigh);
- ++len;
+ if (! arch_irn_is(env->aenv, neigh, ignore)) {
+ obstack_ptr_grow(phase_obst(ph), neigh);
+ ++len;
+ }
}
res->int_neighs = obstack_finish(phase_obst(ph));
res->n_neighs = len;
* Check if affinity chunk @p chunk interferes with node @p irn.
*/
static INLINE int aff_chunk_interferes(co_mst_env_t *env, const aff_chunk_t *chunk, ir_node *irn) {
- const co_mst_irn_t *node = get_co_mst_irn(env, irn);
- const ir_node *neigh;
- int i;
-
- for (i = 0; i < node->n_neighs; ++i) {
- neigh = node->int_neighs[i];
- if (! arch_irn_is(env->aenv, neigh, ignore) && bitset_is_set(chunk->nodes, get_irn_idx(neigh)))
- return 1;
- }
-
- return 0;
+ (void) env;
+ return bitset_is_set(chunk->interfere, get_irn_idx(irn));
}
/**
* @return 1 if there are interferences between nodes of c1 and c2, 0 otherwise.
*/
static INLINE int aff_chunks_interfere(co_mst_env_t *env, const aff_chunk_t *c1, const aff_chunk_t *c2) {
- int idx;
-
+ (void) env;
if (c1 == c2)
return 0;
/* check if there is a node in c2 having an interfering neighbor in c1 */
- bitset_foreach(c2->nodes, idx) {
- ir_node *n = get_idx_irn(env->co->irg, idx);
-
- if (aff_chunk_interferes(env, c1, n))
- return 1;
- }
-
- return 0;
+ return bitset_intersect(c1->interfere, c2->nodes);
}
/**
aff_chunk_t *c1 = get_aff_chunk(env, src);
aff_chunk_t *c2 = get_aff_chunk(env, tgt);
- DEBUG_ONLY(
+#ifdef DEBUG_libfirm
DB((dbg, LEVEL_4, "Attempt to let c1 (id %d): ", c1 ? c1->id : -1));
if (c1) {
DBG_AFF_CHUNK(env, LEVEL_4, c1);
DB((dbg, LEVEL_4, "{%+F}", tgt));
}
DB((dbg, LEVEL_4, "\n"));
- )
+#endif
if (c1 == NULL) {
if (c2 == NULL) {
goto absorbed;
}
} else if (c1 != c2 && ! aff_chunks_interfere(env, c1, c2)) {
- int idx;
-
- bitset_or(c1->nodes, c2->nodes);
- c1->weight_consistent = 0;
+ int idx, len;
- bitset_foreach(c2->nodes, idx) {
- ir_node *n = get_idx_irn(env->co->irg, idx);
+ for (idx = 0, len = ARR_LEN(c2->n); idx < len; ++idx) {
+ ir_node *n = c2->n[idx];
co_mst_irn_t *mn = get_co_mst_irn(env, n);
+
mn->chunk = c1;
+
+ if (! bitset_is_set(c1->nodes, get_irn_idx(n)))
+ ARR_APP1(ir_node *, c1->n, n);
}
+ bitset_or(c1->nodes, c2->nodes);
+ bitset_or(c1->interfere, c2->interfere);
+ c1->weight_consistent = 0;
+
delete_aff_chunk(env, c2);
goto absorbed;
}
/**
* Assures that the weight of the given chunk is consistent.
*/
-static void aff_chunk_assure_weight(const co_mst_env_t *env, aff_chunk_t *c) {
+static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
if (! c->weight_consistent) {
int w = 0;
- int idx;
+ int idx, len, i;
+
+ for (i = 0; i < env->k; ++i) {
+ c->color_affinity[i].col = i;
+ c->color_affinity[i].cost = 0.0;
+ }
+
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+ ir_node *n = c->n[idx];
+ const affinity_node_t *an = get_affinity_info(env->co, n);
+ co_mst_irn_t *node = get_co_mst_irn(env, n);
- bitset_foreach(c->nodes, idx) {
- ir_node *n = get_idx_irn(env->co->irg, idx);
- const affinity_node_t *an = get_affinity_info(env->co, n);
+ if (node->constr_factor > 0.0) {
+ bitset_pos_t col;
+ bitset_foreach (node->adm_colors, col)
+ c->color_affinity[col].cost -= node->constr_factor;
+ }
if (an != NULL) {
neighb_t *neigh;
co_gs_foreach_neighb(an, neigh) {
- const ir_node *m = neigh->irn;
- const int m_idx = get_irn_idx(m);
+ const ir_node *m = neigh->irn;
+ const int m_idx = get_irn_idx(m);
/* skip ignore nodes */
if (arch_irn_is(env->aenv, m, ignore))
ir_node *n;
int i, len;
aff_chunk_t *curr_chunk;
- pset_new_iterator_t iter;
/* at first we create the affinity edge objects */
be_ifg_foreach_node(env->ifg, nodes_it, n) {
if (n1->int_aff_neigh < 0)
n1->int_aff_neigh = count_interfering_aff_neighs(env, an);
+
+ /* build the affinity edges */
co_gs_foreach_neighb(an, neigh) {
ir_node *m = neigh->irn;
int m_idx = get_irn_idx(m);
affinity_node_t *am = get_affinity_info(env->co, m);
n2->int_aff_neigh = count_interfering_aff_neighs(env, am);
}
+ /*
+ * these weights are pure hackery ;-).
+ * It's not chriswue's fault but mine.
+ */
edge.weight = (double)neigh->costs / (double)(1 + n1->int_aff_neigh + n2->int_aff_neigh);
ARR_APP1(aff_edge_t, edges, edge);
}
}
/* now insert all chunks into a priority queue */
- foreach_pset_new(&env->chunkset, curr_chunk, iter) {
+ foreach_pset(env->chunkset, curr_chunk) {
aff_chunk_assure_weight(env, curr_chunk);
DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
DEL_ARR_F(edges);
}
+static void chunk_order_nodes(co_mst_env_t *env, aff_chunk_t *chunk)
+{
+ pqueue *grow = new_pqueue();
+ int i;
+ int max_weight = 0;
+ ir_node *max_node = NULL;
+
+ for (i = ARR_LEN(chunk->n) - 1; i >= 0; i--) {
+ ir_node *irn = chunk->n[i];
+ affinity_node_t *an = get_affinity_info(env->co, irn);
+ int w = 0;
+ neighb_t *neigh;
+
+ if (arch_irn_is(env->aenv, irn, ignore))
+ continue;
+
+ if (an) {
+ co_gs_foreach_neighb(an, neigh)
+ w += neigh->costs;
+
+ if (w > max_weight) {
+ max_weight = w;
+ max_node = irn;
+ }
+ }
+ }
+
+ if (max_node) {
+ bitset_t *visited = bitset_irg_malloc(env->co->irg);
+
+ for (i = ARR_LEN(chunk->n) - 1; i >= 0; --i)
+ bitset_add_irn(visited, chunk->n[i]);
+
+ pqueue_put(grow, max_node, max_weight);
+ bitset_remv_irn(visited, max_node);
+ i = 0;
+ while (!pqueue_empty(grow)) {
+ ir_node *irn = pqueue_get(grow);
+ affinity_node_t *an = get_affinity_info(env->co, irn);
+ neighb_t *neigh;
+
+ if (arch_irn_is(env->aenv, irn, ignore))
+ continue;
+
+ assert(i <= ARR_LEN(chunk->n));
+ chunk->n[i++] = irn;
+
+ assert(an);
+
+ /* build the affinity edges */
+ co_gs_foreach_neighb(an, neigh) {
+ co_mst_irn_t *node = get_co_mst_irn(env, neigh->irn);
+
+ if (bitset_contains_irn(visited, node->irn)) {
+ pqueue_put(grow, neigh->irn, neigh->costs);
+ bitset_remv_irn(visited, node->irn);
+ }
+ }
+ }
+
+ del_pqueue(grow);
+ bitset_free(visited);
+ }
+}
+
/**
* Greedy collect affinity neighbours into thew new chunk @p chunk starting at node @p node.
*/
{
waitq *nodes = new_waitq();
- DBG((dbg, LEVEL_1, "\nExpanding new chunk (id %d) from %+F:", chunk->id, node->irn));
+ DBG((dbg, LEVEL_1, "\n\tExpanding new chunk (#%d) from %+F, color %d:", chunk->id, node->irn, col));
/* init queue and chunk */
waitq_put(nodes, node);
*/
static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, waitq *tmp) {
bitset_t *visited = bitset_irg_malloc(env->co->irg);
- int idx;
+ int idx, len;
aff_chunk_t *best = NULL;
- bitset_foreach(c->nodes, idx) {
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
ir_node *irn;
co_mst_irn_t *node;
aff_chunk_t *tmp_chunk;
decide_func_t *decider;
int check_for_best;
- if (bitset_is_set(visited, idx))
+ irn = c->n[idx];
+ if (bitset_is_set(visited, get_irn_idx(irn)))
continue;
- irn = get_idx_irn(env->co->irg, idx);
node = get_co_mst_irn(env, irn);
if (get_mst_irn_col(node) == col) {
decider = decider_has_color;
check_for_best = 1;
+ DBG((dbg, LEVEL_4, "\tcolor %d wanted", col));
}
else {
decider = decider_hasnot_color;
check_for_best = 0;
+ DBG((dbg, LEVEL_4, "\tcolor %d forbidden", col));
}
/* create a new chunk starting at current node */
* Resets the temporary fixed color of all nodes within wait queue @p nodes.
* ATTENTION: the queue is empty after calling this function!
*/
-static INLINE void reject_coloring(waitq *nodes) {
- while (! waitq_empty(nodes)) {
- co_mst_irn_t *n = waitq_get(nodes);
- n->tmp_fixed = 0;
+static INLINE void reject_coloring(struct list_head *nodes) {
+ co_mst_irn_t *n, *temp;
+ DB((dbg, LEVEL_4, "\treject coloring for"));
+ list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) {
+ DB((dbg, LEVEL_4, " %+F", n->irn));
+ assert(n->tmp_col >= 0);
+ n->tmp_col = -1;
+ list_del_init(&n->list);
+ }
+ DB((dbg, LEVEL_4, "\n"));
+}
+
+static INLINE void materialize_coloring(struct list_head *nodes) {
+ co_mst_irn_t *n, *temp;
+ list_for_each_entry_safe(co_mst_irn_t, n, temp, nodes, list) {
+ assert(n->tmp_col >= 0);
+ n->col = n->tmp_col;
+ n->tmp_col = -1;
+ list_del_init(&n->list);
}
}
+static INLINE void set_temp_color(co_mst_irn_t *node, int col, struct list_head *changed)
+{
+ assert(col >= 0);
+ assert(!node->fixed);
+ assert(node->tmp_col < 0);
+ assert(node->list.next == &node->list && node->list.prev == &node->list);
+
+ list_add_tail(&node->list, changed);
+ node->tmp_col = col;
+}
+
+static INLINE int is_loose(co_mst_irn_t *node)
+{
+ return !node->fixed && node->tmp_col < 0;
+}
+
/**
* Determines the costs for each color if it would be assigned to node @p node.
*/
static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs) {
affinity_node_t *an = get_affinity_info(env->co, node->irn);
neighb_t *aff_neigh;
- int idx, i;
+ bitset_pos_t idx;
+ int i;
col_cost_init(env, costs, 0.0);
c = (double)aff_neigh->costs;
/* calculate costs for fixed affinity neighbours */
- if (neigh->tmp_fixed || neigh->fixed) {
+ if (!is_loose(neigh)) {
int col = get_mst_irn_col(neigh);
costs[col].cost -= c * AFF_NEIGHBOUR_FIX_BENEFIT;
}
int_neigh = node->int_neighs[i];
- /* skip ignore nodes */
- if (arch_irn_is(env->aenv, int_neigh, ignore))
- continue;
+ assert(!arch_irn_is(env->aenv, int_neigh, ignore));
neigh = get_co_mst_irn(env, int_neigh);
col = get_mst_irn_col(neigh);
col_cnt = bitset_popcnt(neigh->adm_colors);
- if (neigh->tmp_fixed || neigh->fixed) {
+ if (!is_loose(neigh)) {
/* colors of fixed interfering neighbours are infeasible */
costs[col].cost = COL_COST_INFEASIBLE;
}
}
}
}
+
+ DB((dbg, LEVEL_4, "\tneigh %+F, loose: %d, color: %d\n", int_neigh, is_loose(neigh), col));
}
/* set all not admissible colors to COL_COST_INFEASIBLE */
}
/* need forward declaration due to recursive call */
-static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, waitq *changed_ones);
+static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, struct list_head *changed_ones, int depth);
/**
* Tries to change node to a color but @p explude_col.
* @return 1 if succeeded, 0 otherwise.
*/
-static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int exclude_col, waitq *changed_ones) {
+static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int exclude_col, struct list_head *changed_ones, int depth) {
int col = get_mst_irn_col(node);
int res = 0;
/* neighbours has already a different color -> good, temporary fix it */
if (col != exclude_col) {
- node->tmp_fixed = 1;
- node->tmp_col = col;
- waitq_put(changed_ones, node);
+ if (is_loose(node))
+ set_temp_color(node, col, changed_ones);
return 1;
}
/* The node has the color it should not have _and_ has not been visited yet. */
- if (! (node->tmp_fixed || node->fixed)) {
+ if (is_loose(node)) {
col_cost_t *costs = alloca(env->n_regs * sizeof(costs[0]));
/* Get the costs for giving the node a specific color. */
qsort(costs, env->n_regs, sizeof(costs[0]), cmp_col_cost);
/* Try recoloring the node using the color list. */
- res = recolor_nodes(env, node, costs, changed_ones);
+ res = recolor_nodes(env, node, costs, changed_ones, depth + 1);
}
return res;
* ATTENTION: Expect @p costs already sorted by increasing costs.
* @return 1 if coloring could be applied, 0 otherwise.
*/
-static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, waitq *changed_ones) {
+static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, struct list_head *changed_ones, int depth) {
int i;
- waitq *local_changed = new_waitq();
- waitq *tmp = new_waitq();
+ struct list_head local_changed;
+
+ if (depth >= recolor_limit)
+ return 0;
DBG((dbg, LEVEL_1, "\tRecoloring %+F with color-costs", node->irn));
DBG_COL_COST(env, LEVEL_1, costs);
/* If the costs for that color (and all successive) are infinite, bail out we won't make it anyway. */
if (costs[i].cost == COL_COST_INFEASIBLE) {
- node->tmp_fixed = 0;
- del_waitq(local_changed);
- del_waitq(tmp);
return 0;
}
/* Set the new color of the node and mark the node as temporarily fixed. */
- assert(! node->tmp_fixed && "Node must not have been temporary fixed.");
- node->tmp_fixed = 1;
- node->tmp_col = tgt_col;
-
- assert(waitq_empty(local_changed) && "Node queue should be empty here.");
- waitq_put(local_changed, node);
+ assert(node->tmp_col < 0 && "Node must not have been temporary fixed.");
+ INIT_LIST_HEAD(&local_changed);
+ set_temp_color(node, tgt_col, &local_changed);
+ DBG((dbg, LEVEL_4, "\tTemporary setting %+F to color %d\n", node->irn, tgt_col));
/* try to color all interfering neighbours with current color forbidden */
for (j = 0; j < node->n_neighs; ++j) {
continue;
nn = get_co_mst_irn(env, neigh);
+ DB((dbg, LEVEL_4, "\tHandling neighbour %+F, at position %d (fixed: %d, tmp_col: %d, col: %d)\n",
+ neigh, j, nn->fixed, nn->tmp_col, nn->col));
/*
Try to change the color of the neighbor and record all nodes which
*/
if (get_mst_irn_col(nn) == tgt_col) {
/* try to color neighbour with tgt_col forbidden */
- neigh_ok = change_node_color_excluded(env, nn, tgt_col, tmp);
-
- /* join lists of changed nodes */
- while (! waitq_empty(tmp))
- waitq_put(local_changed, waitq_get(tmp));
+ neigh_ok = change_node_color_excluded(env, nn, tgt_col, &local_changed, depth + 1);
- if (! neigh_ok)
+ if (!neigh_ok)
break;
}
}
*/
if (neigh_ok) {
/* append the local_changed ones to global ones */
- while (! waitq_empty(local_changed))
- waitq_put(changed_ones, waitq_get(local_changed));
- del_waitq(local_changed);
- del_waitq(tmp);
+ list_splice(&local_changed, changed_ones);
return 1;
}
else {
/* coloring of neighbours failed, so we try next color */
- reject_coloring(local_changed);
+ reject_coloring(&local_changed);
}
}
- del_waitq(local_changed);
- del_waitq(tmp);
return 0;
}
* Tries to bring node @p node and all it's neighbours to color @p tgt_col.
* @return 1 if color @p col could be applied, 0 otherwise
*/
-static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col, waitq *changed_ones) {
+static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col, struct list_head *changed_ones, int depth) {
int col = get_mst_irn_col(node);
/* if node already has the target color -> good, temporary fix it */
if (col == tgt_col) {
DBG((dbg, LEVEL_4, "\t\tCNC: %+F has already color %d, fix temporary\n", node->irn, tgt_col));
- if (! node->tmp_fixed) {
- node->tmp_fixed = 1;
- node->tmp_col = tgt_col;
- waitq_put(changed_ones, node);
- }
+ if (is_loose(node))
+ set_temp_color(node, tgt_col, changed_ones);
return 1;
}
Node has not yet a fixed color and target color is admissible
-> try to recolor node and it's affinity neighbours
*/
- if (! (node->fixed || node->tmp_fixed) && bitset_is_set(node->adm_colors, tgt_col)) {
+ if (is_loose(node) && bitset_is_set(node->adm_colors, tgt_col)) {
col_cost_t *costs = alloca(env->n_regs * sizeof(costs[0]));
int res;
col_cost_init_single(env, costs, tgt_col);
DBG((dbg, LEVEL_4, "\t\tCNC: Attempt to recolor %+F ===>>\n", node->irn));
- res = recolor_nodes(env, node, costs, changed_ones);
+ res = recolor_nodes(env, node, costs, changed_ones, depth);
DBG((dbg, LEVEL_4, "\t\tCNC: <<=== Recoloring of %+F %s\n", node->irn, res ? "succeeded" : "failed"));
return res;
}
- DEBUG_ONLY(
+#ifdef DEBUG_libfirm
if (firm_dbg_get_mask(dbg) & LEVEL_4) {
- if (node->fixed || node->tmp_fixed)
+ if (!is_loose(node))
DB((dbg, LEVEL_4, "\t\tCNC: %+F has already fixed color %d\n", node->irn, col));
else {
DB((dbg, LEVEL_4, "\t\tCNC: color %d not admissible for %+F (", tgt_col, node->irn));
DB((dbg, LEVEL_4, ")\n"));
}
}
- )
+#endif
return 0;
}
static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
aff_chunk_t *best_chunk = NULL;
int best_color = -1;
- waitq *changed_ones = new_waitq();
+ int did_all = 0;
waitq *tmp_chunks = new_waitq();
+ waitq *best_starts = NULL;
+ col_cost_t *order = alloca(env->k * sizeof(order[0]));
bitset_t *visited;
- int col, idx;
+ int idx, len, i;
+ struct list_head changed_ones;
+ bitset_pos_t pos;
DB((dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
DBG_AFF_CHUNK(env, LEVEL_2, c);
DB((dbg, LEVEL_2, "\n"));
+ /* compute color preference */
+ memcpy(order, c->color_affinity, env->k * sizeof(order[0]));
- /* check which color is the "best" for the given chunk */
- for (col = 0; col < env->k; ++col) {
- int reg_col = env->map_regs[col];
- int one_good = 0;
+ bitset_foreach (c->interfere, pos) {
+ ir_node *n = get_idx_irn(env->co->irg, pos);
+ co_mst_irn_t *node = get_co_mst_irn(env, n);
+ bitset_pos_t col;
+
+ if (node->constr_factor > 0.0 && is_loose(node)) {
+ bitset_foreach (node->adm_colors, col)
+ order[col].cost += node->constr_factor;
+ }
+ }
+
+ qsort(order, env->k, sizeof(order[0]), cmp_col_cost);
+
+ chunk_order_nodes(env, c);
+
+ /* check which color is the "best" for the given chunk.
+ * if we found a color which was ok for all nodes, we take it
+ * and do not look further. (see did_all flag usage below.)
+ * If we have many colors which fit all nodes it is hard to decide
+ * which one to take anyway.
+ * TODO Sebastian: Perhaps we should at all nodes and figure out
+ * a suitable color using costs as done above (determine_color_costs).
+ */
+ for (i = 0; i < env->k && !did_all; ++i) {
+ int col = order[i].col;
+ int one_good = 0;
+ waitq *good_starts = new_waitq();
aff_chunk_t *local_best;
- DB((dbg, LEVEL_3, "\ttrying color %d\n", reg_col));
+ /* skip ignore colors */
+ if (bitset_is_set(env->ignore_regs, col))
+ continue;
+
+ DB((dbg, LEVEL_3, "\ttrying color %d\n", col));
+
+ /* suppose we can color all nodes to the same color */
+ did_all = 1;
+
+ INIT_LIST_HEAD(&changed_ones);
/* try to bring all nodes of given chunk to the current color. */
- bitset_foreach(c->nodes, idx) {
- ir_node *irn = get_idx_irn(env->co->irg, idx);
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+ ir_node *irn = c->n[idx];
co_mst_irn_t *node = get_co_mst_irn(env, irn);
+ int good = 0;
assert(! node->fixed && "Node must not have a fixed color.");
+ DB((dbg, LEVEL_4, "\t\tBringing %+F from color %d to color %d ...\n", irn, node->col, col));
- DB((dbg, LEVEL_4, "\t\tBringing %+F from color %d to color %d ...\n", irn, node->col, reg_col));
- one_good |= change_node_color(env, node, reg_col, changed_ones);
- DB((dbg, LEVEL_4, "\t\t... %+F attempt from %d to %d %s\n", irn, node->col, reg_col, one_good ? "succeeded" : "failed"));
+ /*
+ The order of the colored nodes is important, so we record the successfully
+ colored ones in the order they appeared.
+ */
+ good = change_node_color(env, node, col, &changed_ones, 0);
+ if (good) {
+ waitq_put(good_starts, node);
+ }
+
+ one_good |= good;
+ did_all &= good;
+
+ DB((dbg, LEVEL_4, "\t\t... %+F attempt from %d to %d %s\n", irn, node->col, col, one_good ? "succeeded" : "failed"));
}
/* try next color when failed */
- if (! one_good)
+ if (! one_good) {
+ reject_coloring(&changed_ones);
continue;
+ }
/* fragment the chunk according to the coloring */
- local_best = fragment_chunk(env, reg_col, c, tmp_chunks);
+ local_best = fragment_chunk(env, col, c, tmp_chunks);
/* search the best of the good list
and make it the new best if it is better than the current */
if (local_best) {
aff_chunk_assure_weight(env, local_best);
- DB((dbg, LEVEL_4, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, reg_col));
+ DB((dbg, LEVEL_4, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, col));
DBG_AFF_CHUNK(env, LEVEL_4, local_best);
if (! best_chunk || best_chunk->weight < local_best->weight) {
best_chunk = local_best;
- best_color = reg_col;
+ best_color = col;
+ if (best_starts)
+ del_waitq(best_starts);
+ best_starts = good_starts;
DB((dbg, LEVEL_4, "\n\t\t... setting global best chunk (id %d), color %d\n", best_chunk->id, best_color));
} else {
DB((dbg, LEVEL_4, "\n\t\t... omitting, global best is better\n"));
+ del_waitq(good_starts);
}
}
+ else {
+ del_waitq(good_starts);
+ }
- /* reject the coloring and bring the coloring to the initial state */
- reject_coloring(changed_ones);
+ reject_coloring(&changed_ones);
}
/* free all intermediate created chunks except best one */
/* return if coloring failed */
if (! best_chunk) {
- del_waitq(changed_ones);
+ if (best_starts)
+ del_waitq(best_starts);
return;
}
DBG_AFF_CHUNK(env, LEVEL_2, best_chunk);
DB((dbg, LEVEL_2, "using color %d\n", best_color));
- /* get the best fragment from the best list and color it */
- bitset_foreach(best_chunk->nodes, idx) {
- ir_node *irn = get_idx_irn(env->co->irg, idx);
+ INIT_LIST_HEAD(&changed_ones);
+ for (idx = 0, len = ARR_LEN(best_chunk->n); idx < len; ++idx) {
+ ir_node *irn = best_chunk->n[idx];
co_mst_irn_t *node = get_co_mst_irn(env, irn);
- int res;
-
- res = change_node_color(env, node, best_color, changed_ones);
- assert(res && "color manifesting failed");
- node->fixed = 1;
- node->chunk = best_chunk;
- }
-
- /* materialize colors on changed nodes */
- while (! waitq_empty(changed_ones)) {
- co_mst_irn_t *n = waitq_get(changed_ones);
- n->tmp_fixed = 0;
- n->col = n->tmp_col;
+ int res;
+
+ /* bring the node to the color. */
+ DB((dbg, LEVEL_4, "\tManifesting color %d for %+F, chunk #%d\n", best_color, node->irn, best_chunk->id));
+ INIT_LIST_HEAD(&changed_ones);
+ res = change_node_color(env, node, best_color, &changed_ones, 0);
+ if (res) {
+ materialize_coloring(&changed_ones);
+ node->fixed = 1;
+ }
}
/* remove the nodes in best chunk from original chunk */
bitset_andnot(c->nodes, best_chunk->nodes);
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+ ir_node *irn = c->n[idx];
+
+ if (bitset_is_set(best_chunk->nodes, get_irn_idx(irn))) {
+ int last = ARR_LEN(c->n) - 1;
+
+ c->n[idx] = c->n[last];
+ ARR_SHRINKLEN(c->n, last);
+ len--;
+ }
+ }
/* we have to get the nodes back into the original chunk because they are scattered over temporary chunks */
- bitset_foreach(c->nodes, idx) {
- ir_node *n = get_idx_irn(env->co->irg, idx);
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+ ir_node *n = c->n[idx];
co_mst_irn_t *nn = get_co_mst_irn(env, n);
nn->chunk = c;
}
/* fragment the remaining chunk */
visited = bitset_irg_malloc(env->co->irg);
bitset_or(visited, best_chunk->nodes);
- bitset_foreach(c->nodes, idx) {
- if (! bitset_is_set(visited, idx)) {
+ for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
+ ir_node *irn = c->n[idx];
+ if (! bitset_is_set(visited, get_irn_idx(irn))) {
aff_chunk_t *new_chunk = new_aff_chunk(env);
- ir_node *irn = get_idx_irn(env->co->irg, idx);
co_mst_irn_t *node = get_co_mst_irn(env, irn);
expand_chunk_from(env, node, visited, new_chunk, c, decider_always_yes, 0);
/* clear obsolete chunks and free some memory */
delete_aff_chunk(env, best_chunk);
bitset_free(visited);
- del_waitq(changed_ones);
+ if (best_starts)
+ del_waitq(best_starts);
}
/**
* Main driver for mst safe coalescing algorithm.
*/
-int co_solve_heuristic_mst(copy_opt_t *co)
-{
+int co_solve_heuristic_mst(copy_opt_t *co) {
unsigned n_regs = co->cls->n_regs;
bitset_t *ignore_regs = bitset_alloca(n_regs);
- unsigned k, idx, num;
+ unsigned k;
ir_node *irn;
co_mst_env_t mst_env;
k = be_put_ignore_regs(co->cenv->birg, co->cls, ignore_regs);
k = n_regs - k;
- /* Create a color to register number map. In some architectures registers are ignore "in the middle"
- of the register set. */
- mst_env.map_regs = NEW_ARR_D(int, phase_obst(&mst_env.ph), k);
- for (idx = num = 0; idx < n_regs; ++idx) {
- if (bitset_is_set(ignore_regs, idx))
- continue;
- mst_env.map_regs[num++] = idx;
- }
- assert(num == k);
-
mst_env.n_regs = n_regs;
mst_env.k = k;
mst_env.chunks = new_pqueue();
mst_env.ignore_regs = ignore_regs;
mst_env.ifg = co->cenv->ifg;
mst_env.aenv = co->aenv;
- pset_new_init(&mst_env.chunkset);
+ mst_env.chunkset = pset_new_ptr(512);
DBG((dbg, LEVEL_1, "==== Coloring %+F, class %s ====\n", co->irg, co->cls->name));
if (arch_irn_is(mst_env.aenv, irn, ignore))
continue;
- assert(mirn->fixed && "Node should have fixed color");
+ // assert(mirn->fixed && "Node should have fixed color");
/* skip nodes where color hasn't changed */
if (mirn->init_col == mirn->col)
/* free allocated memory */
del_pqueue(mst_env.chunks);
phase_free(&mst_env.ph);
- pset_new_destroy(&mst_env.chunkset);
+ del_pset(mst_env.chunkset);
return 0;
}
+static const lc_opt_table_entry_t options[] = {
+ LC_OPT_ENT_INT ("limit", "limit recoloring", &recolor_limit),
+ LC_OPT_LAST
+};
+
+
void be_init_copyheur4(void) {
+ lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
+ lc_opt_entry_t *ra_grp = lc_opt_get_grp(be_grp, "ra");
+ lc_opt_entry_t *chordal_grp = lc_opt_get_grp(ra_grp, "chordal");
+ lc_opt_entry_t *co_grp = lc_opt_get_grp(chordal_grp, "co");
+ lc_opt_entry_t *heur4_grp = lc_opt_get_grp(co_grp, "heur4");
+
+ lc_opt_add_table(heur4_grp, options);
FIRM_DBG_REGISTER(dbg, "firm.be.co.heur4");
}
projects / libfirm / blobdiff