* (also known as "heur3" :)
* Performs simple copy minimization.
*/
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif /* HAVE_CONFIG_H */
+#include "config.h" /* HAVE_CONFIG_H */
+
+#define DISABLE_STATEV
#include <float.h>
#endif
-static int last_chunk_id = 0;
-static int recolor_limit = 4;
-static double dislike_influence = 0.1;
+typedef float real_t;
+#define REAL(C) (C ## f)
+
+static unsigned last_chunk_id = 0;
+static int recolor_limit = 7;
+static real_t dislike_influence = REAL(0.1);
typedef struct _col_cost_t {
- int col;
- double cost;
+ int col;
+ real_t cost;
} col_cost_t;
/**
*/
typedef struct _aff_chunk_t {
const 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. */
+ const ir_node **interfere; /**< An ARR_F containing all inference. */
int weight; /**< Weight of this chunk */
unsigned weight_consistent : 1; /**< Set if the weight is consistent. */
unsigned deleted : 1; /**< For debugging: Set if the was deleted. */
- int id; /**< An id of this chunk. */
- int visited;
- col_cost_t *color_affinity;
+ unsigned id; /**< An id of this chunk. */
+ unsigned visited;
+ col_cost_t color_affinity[1];
} aff_chunk_t;
/**
typedef struct _aff_edge_t {
const ir_node *src; /**< Source node. */
const ir_node *tgt; /**< Target node. */
- double weight; /**< The weight of this edge. */
+ int weight; /**< The weight of this edge. */
} aff_edge_t;
/* main coalescing environment */
int k; /**< number of non-ignore registers in class */
bitset_t *ignore_regs; /**< set containing all global ignore registers */
ir_phase ph; /**< phase object holding data for nodes */
- pqueue *chunks; /**< priority queue for chunks */
+ pqueue_t *chunks; /**< priority queue for 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 */
- int chunk_visited;
+ unsigned chunk_visited;
col_cost_t **single_cols;
} co_mst_env_t;
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;
+ real_t 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) {
- bitset_pos_t idx;
+ int i, l;
+ (void) env;
if (c->weight_consistent)
ir_fprintf(stderr, " $%d ", c->weight);
ir_fprintf(stderr, "{");
- bitset_foreach(c->nodes, idx) {
- ir_node *n = get_idx_irn(env->co->irg, idx);
+ for (i = 0, l = ARR_LEN(c->n); i < l; ++i) {
+ const ir_node *n = c->n[i];
ir_fprintf(stderr, " %+F,", n);
}
ir_fprintf(stderr, "}");
if (bitset_popcnt(node->adm_colors) < 1)
fprintf(stderr, "no admissible colors?!?");
else {
- bitset_foreach(node->adm_colors, idx)
+ bitset_foreach(node->adm_colors, idx) {
fprintf(stderr, " %d", idx);
+ }
}
}
static __attribute__((unused)) int cmp_col_cost_lt(const void *a, const void *b) {
const col_cost_t *c1 = a;
const col_cost_t *c2 = b;
- double diff = c1->cost - c2->cost;
+ real_t diff = c1->cost - c2->cost;
return (diff > 0) - (diff < 0);
}
static int cmp_col_cost_gt(const void *a, const void *b) {
const col_cost_t *c1 = a;
const col_cost_t *c2 = b;
- double diff = c2->cost - c1->cost;
+ real_t diff = c2->cost - c1->cost;
return (diff > 0) - (diff < 0);
}
* Creates a new affinity chunk
*/
static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
- aff_chunk_t *c = xmalloc(sizeof(*c));
+ aff_chunk_t *c = XMALLOCF(aff_chunk_t, color_affinity, env->n_regs);
+ c->n = NEW_ARR_F(const ir_node *, 0);
+ c->interfere = NEW_ARR_F(const ir_node *, 0);
c->weight = -1;
c->weight_consistent = 0;
- c->n = NEW_ARR_F(const ir_node *, 0);
- c->nodes = bitset_irg_malloc(env->co->irg);
- c->interfere = bitset_irg_malloc(env->co->irg);
- c->color_affinity = xmalloc(env->n_regs * sizeof(c->color_affinity[0]));
c->deleted = 0;
- c->id = last_chunk_id++;
+ c->id = ++last_chunk_id;
c->visited = 0;
pset_insert(env->chunkset, c, c->id);
return c;
*/
static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
pset_remove(env->chunkset, c, c->id);
- bitset_free(c->nodes);
- bitset_free(c->interfere);
- xfree(c->color_affinity);
+ DEL_ARR_F(c->interfere);
DEL_ARR_F(c->n);
c->deleted = 1;
free(c);
}
+/**
+ * binary search of sorted nodes.
+ *
+ * @return the position where n is found in the array arr or ~pos
+ * if the nodes is not here.
+ */
+static INLINE int nodes_bsearch(const ir_node **arr, const ir_node *n) {
+ int hi = ARR_LEN(arr);
+ int lo = 0;
+
+ while (lo < hi) {
+ int md = lo + ((hi - lo) >> 1);
+
+ if (arr[md] == n)
+ return md;
+ if (arr[md] < n)
+ lo = md + 1;
+ else
+ hi = md;
+ }
+
+ return ~lo;
+}
+
+/** Check if a node n can be found inside arr. */
+static int node_contains(const ir_node **arr, const ir_node *n) {
+ int i = nodes_bsearch(arr, n);
+ return i >= 0;
+}
+
+/**
+ * Insert a node into the sorted nodes list.
+ *
+ * @return 1 if the node was inserted, 0 else
+ */
+static int nodes_insert(const ir_node ***arr, const ir_node *irn) {
+ int idx = nodes_bsearch(*arr, irn);
+
+ if (idx < 0) {
+ int i, n = ARR_LEN(*arr);
+ const ir_node **l;
+
+ ARR_APP1(const ir_node *, *arr, irn);
+
+ /* move it */
+ idx = ~idx;
+ l = *arr;
+ for (i = n - 1; i >= idx; --i)
+ l[i + 1] = l[i];
+ l[idx] = irn;
+ return 1;
+ }
+ return 0;
+}
+
/**
* 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)))
+ if (! nodes_insert(&c->n, 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));
+ nodes_insert(&c->interfere, neigh);
}
}
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->col = arch_register_get_index(arch_get_irn_register(irn));
res->init_col = res->col;
INIT_LIST_HEAD(&res->list);
res->adm_colors = bitset_obstack_alloc(phase_obst(ph), env->n_regs);
/* Exclude colors not assignable to the irn */
- req = arch_get_register_req(env->aenv, irn, -1);
+ req = arch_get_register_req(irn, -1);
if (arch_register_req_is(req, limited))
rbitset_copy_to_bitset(req->limited, res->adm_colors);
else
bitset_andnot(res->adm_colors, env->ignore_regs);
/* compute the constraint factor */
- res->constr_factor = (double) (1 + env->n_regs - bitset_popcnt(res->adm_colors)) / env->n_regs;
+ res->constr_factor = (real_t) (1 + env->n_regs - bitset_popcnt(res->adm_colors)) / env->n_regs;
/* set the number of interfering affinity neighbours to -1, they are calculated later */
res->int_aff_neigh = -1;
/* build list of interfering neighbours */
len = 0;
be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
- if (! arch_irn_is(env->aenv, neigh, ignore)) {
+ if (!arch_irn_is(neigh, ignore)) {
obstack_ptr_grow(phase_obst(ph), neigh);
++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, const ir_node *irn) {
- (void) env;
- return bitset_is_set(chunk->interfere, get_irn_idx(irn));
+static INLINE int aff_chunk_interferes(const aff_chunk_t *chunk, const ir_node *irn) {
+ return node_contains(chunk->interfere, irn);
}
/**
* Check if there are interference edges from c1 to c2.
- * @param env The global co_mst environment
* @param c1 A chunk
* @param c2 Another chunk
* @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) {
- (void) env;
+static INLINE int aff_chunks_interfere(const aff_chunk_t *c1, const aff_chunk_t *c2) {
+ int i;
+
if (c1 == c2)
return 0;
/* check if there is a node in c2 having an interfering neighbor in c1 */
- return bitset_intersect(c1->interfere, c2->nodes);
+ for (i = ARR_LEN(c2->n) - 1; i >= 0; --i) {
+ const ir_node *irn = c2->n[i];
+
+ if (node_contains(c1->interfere, irn))
+ return 1;
+ }
+ return 0;
}
/**
aff_chunk_t *c2 = get_aff_chunk(env, tgt);
#ifdef DEBUG_libfirm
- DB((dbg, LEVEL_4, "Attempt to let c1 (id %d): ", c1 ? c1->id : -1));
+ DB((dbg, LEVEL_4, "Attempt to let c1 (id %u): ", c1 ? c1->id : 0));
if (c1) {
DBG_AFF_CHUNK(env, LEVEL_4, c1);
} else {
DB((dbg, LEVEL_4, "{%+F}", src));
}
- DB((dbg, LEVEL_4, "\n\tabsorb c2 (id %d): ", c2 ? c2->id : -1));
+ DB((dbg, LEVEL_4, "\n\tabsorb c2 (id %u): ", c2 ? c2->id : 0));
if (c2) {
DBG_AFF_CHUNK(env, LEVEL_4, c2);
} else {
}
} else {
/* c2 already exists */
- if (! aff_chunk_interferes(env, c2, src)) {
+ if (! aff_chunk_interferes(c2, src)) {
aff_chunk_add_node(c2, get_co_mst_irn(env, src));
goto absorbed;
}
}
} else if (c2 == NULL) {
/* c1 already exists */
- if (! aff_chunk_interferes(env, c1, tgt)) {
+ if (! aff_chunk_interferes(c1, tgt)) {
aff_chunk_add_node(c1, get_co_mst_irn(env, tgt));
goto absorbed;
}
- } else if (c1 != c2 && ! aff_chunks_interfere(env, c1, c2)) {
+ } else if (c1 != c2 && ! aff_chunks_interfere(c1, c2)) {
int idx, len;
for (idx = 0, len = ARR_LEN(c2->n); idx < len; ++idx)
aff_chunk_add_node(c1, get_co_mst_irn(env, c2->n[idx]));
- bitset_or(c1->interfere, c2->interfere);
+ for (idx = 0, len = ARR_LEN(c2->interfere); idx < len; ++idx) {
+ const ir_node *irn = c2->interfere[idx];
+ nodes_insert(&c1->interfere, irn);
+ }
+
c1->weight_consistent = 0;
delete_aff_chunk(env, c2);
for (i = 0; i < env->n_regs; ++i) {
c->color_affinity[i].col = i;
- c->color_affinity[i].cost = 0.0;
+ c->color_affinity[i].cost = REAL(0.0);
}
for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
co_mst_irn_t *node = get_co_mst_irn(env, n);
node->chunk = c;
- if (node->constr_factor > 0.0) {
+ if (node->constr_factor > REAL(0.0)) {
bitset_pos_t col;
bitset_foreach (node->adm_colors, col)
c->color_affinity[col].cost += node->constr_factor;
neighb_t *neigh;
co_gs_foreach_neighb(an, neigh) {
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))
+ if (arch_irn_is(m, ignore))
continue;
- w += bitset_is_set(c->nodes, m_idx) ? neigh->costs : 0;
+ w += node_contains(c->n, m) ? neigh->costs : 0;
}
}
}
for (i = 0; i < env->n_regs; ++i)
- c->color_affinity[i].cost *= (1.0 / ARR_LEN(c->n));
+ c->color_affinity[i].cost *= (REAL(1.0) / ARR_LEN(c->n));
c->weight = w;
// c->weight = bitset_popcnt(c->nodes);
int i;
/* skip ignore nodes */
- if (arch_irn_is(env->aenv, n, ignore))
+ if (arch_irn_is(n, ignore))
continue;
/* check if the affinity neighbour interfere */
affinity_node_t *an;
/* skip ignore nodes */
- if (arch_irn_is(env->aenv, n, ignore))
+ if (arch_irn_is(n, ignore))
continue;
n1 = get_co_mst_irn(env, n);
aff_edge_t edge;
/* skip ignore nodes */
- if (arch_irn_is(env->aenv, m, ignore))
+ if (arch_irn_is(m, ignore))
continue;
edge.src = n;
foreach_pset(env->chunkset, curr_chunk) {
aff_chunk_assure_weight(env, curr_chunk);
- DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
+ DBG((dbg, LEVEL_1, "entry #%u", curr_chunk->id));
DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
DBG((dbg, LEVEL_1, "\n"));
pqueue_put(env->chunks, curr_chunk, curr_chunk->weight);
}
+
foreach_phase_irn(&env->ph, n) {
co_mst_irn_t *mirn = get_co_mst_irn(env, n);
aff_chunk_assure_weight(env, curr_chunk);
- DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
+ DBG((dbg, LEVEL_1, "entry #%u", curr_chunk->id));
DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
DBG((dbg, LEVEL_1, "\n"));
static __attribute__((unused)) void chunk_order_nodes(co_mst_env_t *env, aff_chunk_t *chunk)
{
- pqueue *grow = new_pqueue();
+ pqueue_t *grow = new_pqueue();
const ir_node *max_node = NULL;
int max_weight = 0;
int i;
int w = 0;
neighb_t *neigh;
- if (arch_irn_is(env->aenv, irn, ignore))
+ if (arch_irn_is(irn, ignore))
continue;
if (an) {
bitset_remv_irn(visited, max_node);
i = 0;
while (!pqueue_empty(grow)) {
- ir_node *irn = pqueue_get(grow);
+ ir_node *irn = pqueue_pop_front(grow);
affinity_node_t *an = get_affinity_info(env->co, irn);
neighb_t *neigh;
- if (arch_irn_is(env->aenv, irn, ignore))
+ if (arch_irn_is(irn, ignore))
continue;
assert(i <= ARR_LEN(chunk->n));
{
waitq *nodes = new_waitq();
- DBG((dbg, LEVEL_1, "\n\tExpanding new chunk (#%d) from %+F, color %d:", chunk->id, node->irn, col));
+ DBG((dbg, LEVEL_1, "\n\tExpanding new chunk (#%u) from %+F, color %d:", chunk->id, node->irn, col));
/* init queue and chunk */
waitq_put(nodes, node);
co_mst_irn_t *n2;
/* skip ignore nodes */
- if (arch_irn_is(env->aenv, m, ignore))
+ if (arch_irn_is(m, ignore))
continue;
n2 = get_co_mst_irn(env, m);
- if (! bitset_is_set(visited, m_idx) &&
- decider(n2, col) &&
- ! n2->fixed &&
- ! aff_chunk_interferes(env, chunk, m) &&
- bitset_is_set(orig_chunk->nodes, m_idx))
+ if (! bitset_is_set(visited, m_idx) &&
+ decider(n2, col) &&
+ ! n2->fixed &&
+ ! aff_chunk_interferes(chunk, m) &&
+ node_contains(orig_chunk->n, m))
{
/*
following conditions are met:
if (get_mst_irn_col(node) == col) {
decider = decider_has_color;
check_for_best = 1;
- DBG((dbg, LEVEL_4, "\tcolor %d wanted", col));
+ DBG((dbg, LEVEL_4, "\tcolor %d wanted\n", col));
}
else {
decider = decider_hasnot_color;
check_for_best = 0;
- DBG((dbg, LEVEL_4, "\tcolor %d forbidden", col));
+ DBG((dbg, LEVEL_4, "\tcolor %d forbidden\n", col));
}
/* create a new chunk starting at current node */
tmp_chunk = new_aff_chunk(env);
waitq_put(tmp, tmp_chunk);
expand_chunk_from(env, node, visited, tmp_chunk, c, decider, col);
- assert(bitset_popcnt(tmp_chunk->nodes) > 0 && "No nodes added to chunk");
+ assert(ARR_LEN(tmp_chunk->n) > 0 && "No nodes added to chunk");
/* remember the local best */
aff_chunk_assure_weight(env, tmp_chunk);
static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs) {
int *neigh_cols = alloca(env->n_regs * sizeof(*neigh_cols));
int n_loose = 0;
- double coeff;
+ real_t coeff;
int i;
for (i = 0; i < env->n_regs; ++i) {
neigh_cols[i] = 0;
costs[i].col = i;
- costs[i].cost = bitset_is_set(node->adm_colors, i) ? node->constr_factor : 0.0;
+ costs[i].cost = bitset_is_set(node->adm_colors, i) ? node->constr_factor : REAL(0.0);
}
for (i = 0; i < node->n_neighs; ++i) {
if (is_loose(n)) {
++n_loose;
++neigh_cols[col];
- }
-
- else
- costs[col].cost = 0.0;
+ } else
+ costs[col].cost = REAL(0.0);
}
if (n_loose > 0) {
- coeff = 1.0 / n_loose;
+ coeff = REAL(1.0) / n_loose;
for (i = 0; i < env->n_regs; ++i)
- costs[i].cost *= 1.0 - coeff * neigh_cols[i];
+ costs[i].cost *= REAL(1.0) - coeff * neigh_cols[i];
}
}
determine_color_costs(env, node, costs);
/* Since the node must not have the not_col, set the costs for that color to "infinity" */
- costs[exclude_col].cost = 0.0;
+ costs[exclude_col].cost = REAL(0.0);
/* sort the colors according costs, cheapest first. */
qsort(costs, env->n_regs, sizeof(costs[0]), cmp_col_cost_gt);
if (depth > *max_depth)
*max_depth = depth;
- if (depth >= recolor_limit)
- return 0;
-
DBG((dbg, LEVEL_4, "\tRecoloring %+F with color-costs", node->irn));
DBG_COL_COST(env, LEVEL_4, costs);
DB((dbg, LEVEL_4, "\n"));
+ if (depth >= recolor_limit) {
+ DBG((dbg, LEVEL_4, "\tHit recolor limit\n"));
+ return 0;
+ }
+
for (i = 0; i < env->n_regs; ++i) {
int tgt_col = costs[i].col;
int neigh_ok = 1;
int j;
/* If the costs for that color (and all successive) are infinite, bail out we won't make it anyway. */
- if (costs[i].cost == 0.0)
+ if (costs[i].cost == REAL(0.0)) {
+ DBG((dbg, LEVEL_4, "\tAll further colors forbidden\n"));
return 0;
+ }
/* Set the new color of the node and mark the node as temporarily fixed. */
assert(node->tmp_col < 0 && "Node must not have been temporary fixed.");
neigh = node->int_neighs[j];
/* skip ignore nodes */
- if (arch_irn_is(env->aenv, neigh, ignore))
+ if (arch_irn_is(neigh, ignore))
continue;
nn = get_co_mst_irn(env, neigh);
}
}
+ DBG((dbg, LEVEL_4, "\tAll colors failed\n"));
return 0;
}
waitq *best_starts = NULL;
col_cost_t *order = alloca(env->n_regs * sizeof(order[0]));
bitset_t *visited;
- int idx, len, i;
+ int idx, len, i, nidx, pos;
struct list_head changed;
- bitset_pos_t pos;
- DB((dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
+ DB((dbg, LEVEL_2, "fragmentizing chunk #%u", c->id));
DBG_AFF_CHUNK(env, LEVEL_2, c);
DB((dbg, LEVEL_2, "\n"));
- stat_ev_ctx_push_fmt("heur4_color_chunk", "%d", c->id);
+ stat_ev_ctx_push_fmt("heur4_color_chunk", "%u", c->id);
++env->chunk_visited;
/* compute color preference */
memset(order, 0, env->n_regs * sizeof(order[0]));
- bitset_foreach (c->interfere, pos) {
- ir_node *n = get_idx_irn(env->co->irg, pos);
+ for (pos = 0, len = ARR_LEN(c->interfere); pos < len; ++pos) {
+ const ir_node *n = c->interfere[pos];
co_mst_irn_t *node = get_co_mst_irn(env, n);
aff_chunk_t *chunk = node->chunk;
}
for (i = 0; i < env->n_regs; ++i) {
- double dislike = n_int_chunks > 0 ? 1.0 - order[i].cost / n_int_chunks : 0.0;
+ real_t dislike = n_int_chunks > 0 ? REAL(1.0) - order[i].cost / n_int_chunks : REAL(0.0);
order[i].col = i;
- order[i].cost = (1.0 - dislike_influence) * c->color_affinity[i].cost + dislike_influence * dislike;
+ order[i].cost = (REAL(1.0) - dislike_influence) * c->color_affinity[i].cost + dislike_influence * dislike;
}
qsort(order, env->n_regs, sizeof(order[0]), cmp_col_cost_gt);
if (local_best) {
aff_chunk_assure_weight(env, local_best);
- DB((dbg, LEVEL_3, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, col));
+ DB((dbg, LEVEL_3, "\t\tlocal best chunk (id %u) for color %d: ", local_best->id, col));
DBG_AFF_CHUNK(env, LEVEL_3, local_best);
if (! best_chunk || best_chunk->weight < local_best->weight) {
if (best_starts)
del_waitq(best_starts);
best_starts = good_starts;
- DB((dbg, LEVEL_3, "\n\t\t... setting global best chunk (id %d), color %d\n", best_chunk->id, best_color));
+ DB((dbg, LEVEL_3, "\n\t\t... setting global best chunk (id %u), color %d\n", best_chunk->id, best_color));
} else {
DB((dbg, LEVEL_3, "\n\t\t... omitting, global best is better\n"));
del_waitq(good_starts);
return;
}
- DB((dbg, LEVEL_2, "\tbest chunk #%d ", best_chunk->id));
+ DB((dbg, LEVEL_2, "\tbest chunk #%u ", best_chunk->id));
DBG_AFF_CHUNK(env, LEVEL_2, best_chunk);
DB((dbg, LEVEL_2, "using color %d\n", best_color));
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));
+ DB((dbg, LEVEL_4, "\tManifesting color %d for %+F, chunk #%u\n", best_color, node->irn, best_chunk->id));
INIT_LIST_HEAD(&changed);
stat_ev_tim_push();
res = change_node_color(env, node, best_color, &changed);
}
/* 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) {
- const ir_node *irn = c->n[idx];
+ len = ARR_LEN(best_chunk->n);
+ for (idx = 0; idx < len; ++idx) {
+ const ir_node *irn = best_chunk->n[idx];
+ int pos = nodes_bsearch(c->n, irn);
- if (bitset_is_set(best_chunk->nodes, get_irn_idx(irn))) {
- int last = ARR_LEN(c->n) - 1;
+ if (pos > 0)
+ c->n[pos] = NULL;
+ }
+ len = ARR_LEN(c->n);
+ for (idx = nidx = 0; idx < len; ++idx) {
+ const ir_node *irn = c->n[idx];
- c->n[idx] = c->n[last];
- ARR_SHRINKLEN(c->n, last);
- len--;
+ if (irn != NULL) {
+ c->n[nidx++] = irn;
}
}
+ ARR_SHRINKLEN(c->n, nidx);
+
/* we have to get the nodes back into the original chunk because they are scattered over temporary chunks */
for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
/* fragment the remaining chunk */
visited = bitset_irg_malloc(env->co->irg);
- bitset_or(visited, best_chunk->nodes);
+ for (idx = 0, len = ARR_LEN(best_chunk->n); idx < len; ++idx)
+ bitset_set(visited, get_irn_idx(best_chunk->n[idx]));
+
for (idx = 0, len = ARR_LEN(c->n); idx < len; ++idx) {
const ir_node *irn = c->n[idx];
if (! bitset_is_set(visited, get_irn_idx(irn))) {
ir_node *irn;
co_mst_env_t mst_env;
+ last_chunk_id = 0;
+
stat_ev_tim_push();
/* init phase */
mst_env.co = co;
mst_env.ignore_regs = ignore_regs;
mst_env.ifg = co->cenv->ifg;
- mst_env.aenv = co->aenv;
mst_env.chunkset = pset_new_ptr(512);
mst_env.chunk_visited = 0;
mst_env.single_cols = phase_alloc(&mst_env.ph, sizeof(*mst_env.single_cols) * n_regs);
mst_env.single_cols[i] = vec;
for (j = 0; j < n_regs; ++j) {
vec[j].col = j;
- vec[j].cost = 0.0;
+ vec[j].cost = REAL(0.0);
}
vec[i].col = 0;
vec[0].col = i;
- vec[0].cost = 1.0;
+ vec[0].cost = REAL(1.0);
}
DBG((dbg, LEVEL_1, "==== Coloring %+F, class %s ====\n", co->irg, co->cls->name));
/* color chunks as long as there are some */
while (! pqueue_empty(mst_env.chunks)) {
- aff_chunk_t *chunk = pqueue_get(mst_env.chunks);
+ aff_chunk_t *chunk = pqueue_pop_front(mst_env.chunks);
color_aff_chunk(&mst_env, chunk);
- DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%d) done\n", chunk->id));
+ DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%u) done\n", chunk->id));
delete_aff_chunk(&mst_env, chunk);
}
/* apply coloring */
foreach_phase_irn(&mst_env.ph, irn) {
- co_mst_irn_t *mirn = get_co_mst_irn(&mst_env, irn);
+ co_mst_irn_t *mirn;
const arch_register_t *reg;
- if (arch_irn_is(mst_env.aenv, irn, ignore))
+ if (arch_irn_is(irn, ignore))
continue;
+ mirn = get_co_mst_irn(&mst_env, irn);
// assert(mirn->fixed && "Node should have fixed color");
/* skip nodes where color hasn't changed */
continue;
reg = arch_register_for_index(co->cls, mirn->col);
- arch_set_irn_register(co->aenv, irn, reg);
+ arch_set_irn_register(irn, reg);
DB((dbg, LEVEL_1, "%+F set color from %d to %d\n", irn, mirn->init_col, mirn->col));
}
projects / libfirm / blobdiff