-/**
- * @file becopyheur4.c
- * @brief Simple copy minimization heuristics.
- * @author 27.04.2007
- * @version $Id$
- * @license
- *
- * Copyrigth (C) 1995-2007 University of Karlsruhe. All right reserved.
+/*
+ * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
* This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
* WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE.
- *
- * @summary
+ */
+
+/**
+ * @file
+ * @brief Simple copy minimization heuristics.
+ * @author Christian Wuerdig
+ * @date 27.04.2007
+ * @version $Id$
*
* This is the C implementation of the mst algorithm
* originally written in Java by Sebastian Hack.
* (also known as "heur3" :)
* Performs simple copy minimization.
*/
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
#include "xmalloc.h"
#include "pdeq.h"
#include "irprintf.h"
+#include "irbitset.h"
+#include "error.h"
#include "bearch.h"
#include "beifg.h"
#include "be_t.h"
#include "becopyopt_t.h"
-#include "irbitset.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(if (firm_dbg_get_mask((env)->dbg) & (level)) dbg_aff_chunk((env), (chunk));)
-#define DBG_COL_COST(env, level, cost) DEBUG_ONLY(if (firm_dbg_get_mask((env)->dbg) & (level)) dbg_col_cost((env), (cost));)
+#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))
static int last_chunk_id = 0;
double cost;
} col_cost_t;
+/**
+ * An affinity chunk.
+ */
typedef struct _aff_chunk_t {
- bitset_t *nodes;
- int weight;
- unsigned weight_consistent : 1;
- int id;
+ 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. */
+ int id; /**< For debugging: An id of this chunk. */
} aff_chunk_t;
+/**
+ * An affinity edge.
+ */
typedef struct _aff_edge_t {
- ir_node *src;
- ir_node *tgt;
- double weight;
+ ir_node *src; /**< Source node. */
+ ir_node *tgt; /**< Target node. */
+ double weight; /**< The weight of this edge. */
} aff_edge_t;
-/* main coalescing environment*/
+/* main coalescing environment */
typedef struct _co_mst_env_t {
int n_regs; /**< number of regs in class */
int k; /**< number of non-ignore registers in class */
be_ifg_t *ifg; /**< the interference graph */
const arch_env_t *aenv; /**< the arch environment */
copy_opt_t *co; /**< the copy opt object */
- DEBUG_ONLY(firm_dbg_module_t *dbg);
} co_mst_env_t;
/* stores coalescing related information for a node */
typedef struct _co_mst_irn_t {
- ir_node *irn;
- aff_chunk_t *chunk;
- bitset_t *adm_colors;
- int int_neigh;
- int col;
- int init_col;
- int tmp_col;
- unsigned fixed : 1;
- unsigned tmp_fixed : 1;
+ 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 */
} co_mst_irn_t;
#define get_co_mst_irn(mst_env, irn) (phase_get_or_set_irn_data(&(mst_env)->ph, (irn)))
-typedef int decide_func_t(co_mst_irn_t *node, int col);
+typedef int decide_func_t(const co_mst_irn_t *node, int col);
#ifdef DEBUG_libfirm
/**
* Write a chunk to stderr for debugging.
*/
-static void dbg_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
+static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c) {
int idx;
if (c->weight_consistent)
ir_fprintf(stderr, " $%d ", c->weight);
ir_fprintf(stderr, "}");
}
-static void dbg_admissible_colors(co_mst_env_t *env, co_mst_irn_t *node) {
+/**
+ * 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;
if (bitset_popcnt(node->adm_colors) < 1)
fprintf(stderr, "no admissible colors?!?");
}
}
-static void dbg_col_cost(co_mst_env_t *env, col_cost_t *cost) {
+/**
+ * Dump color-cost pairs to stderr.
+ */
+static void dbg_col_cost(const co_mst_env_t *env, const col_cost_t *cost) {
int i;
for (i = 0; i < env->n_regs; ++i) {
if (cost[i].cost == COL_COST_INFEASIBLE)
#endif /* DEBUG_libfirm */
-static INLINE int get_mst_irn_col(co_mst_irn_t *node) {
+static INLINE int get_mst_irn_col(const co_mst_irn_t *node) {
return node->tmp_fixed ? node->tmp_col : node->col;
}
/**
* @return 1 if node @p node has color @p col, 0 otherwise.
*/
-static int decider_has_color(co_mst_irn_t *node, int col) {
+static int decider_has_color(const co_mst_irn_t *node, int col) {
return get_mst_irn_col(node) == col;
}
/**
* @return 1 if node @p node has not color @p col, 0 otherwise.
*/
-static int decider_hasnot_color(co_mst_irn_t *node, int col) {
+static int decider_hasnot_color(const co_mst_irn_t *node, int col) {
return get_mst_irn_col(node) != col;
}
/**
* Always returns true.
*/
-static int decider_always_yes(co_mst_irn_t *node, int col) {
+static int decider_always_yes(const co_mst_irn_t *node, int col) {
return 1;
}
-/* > compares two affinity edges by its weight */
+/** compares two affinity edges by its weight */
static int cmp_aff_edge(const void *a, const void *b) {
const aff_edge_t *e1 = a;
const aff_edge_t *e2 = b;
return QSORT_CMP(e2->weight, e1->weight);
}
-/* compares to color-cost pairs */
+/** compares to color-cost pairs */
static int cmp_col_cost(const void *a, const void *b) {
const col_cost_t *c1 = a;
const col_cost_t *c2 = b;
c->weight = -1;
c->weight_consistent = 0;
c->nodes = bitset_irg_malloc(env->co->irg);
+ c->interfere = bitset_irg_malloc(env->co->irg);
c->id = last_chunk_id++;
pset_new_insert(&env->chunkset, c);
return c;
static INLINE void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
pset_new_remove(&env->chunkset, c);
bitset_free(c->nodes);
+ bitset_free(c->interfere);
+ memset(c, 0, sizeof(*c));
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;
+
c->weight_consistent = 0;
node->chunk = c;
bitset_set(c->nodes, get_irn_idx(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));
+ }
}
/**
if (res != old) {
const arch_register_req_t *req;
-
- res->irn = irn;
- res->chunk = new_aff_chunk(env);
- res->fixed = 0;
- res->tmp_fixed = 0;
- res->tmp_col = -1;
- res->int_neigh = 0;
- res->col = arch_register_get_index(arch_get_irn_register(env->aenv, irn));
- res->init_col = res->col;
-
- /* add note to new chunk */
- aff_chunk_add_node(res->chunk, res);
-
- DB((env->dbg, LEVEL_4, "Creating phase info for %+F, chunk %d\n", irn, res->chunk->id));
+ void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
+ ir_node *neigh;
+ unsigned len;
+
+ 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;
+
+ DB((dbg, LEVEL_4, "Creating phase info for %+F\n", irn));
/* set admissible registers */
res->adm_colors = bitset_obstack_alloc(phase_obst(ph), env->n_regs);
bitset_andnot(res->adm_colors, env->ignore_regs);
/* set the number of interfering affinity neighbours to -1, they are calculated later */
- res->int_neigh = -1;
+ 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)) {
+ obstack_ptr_grow(phase_obst(ph), neigh);
+ ++len;
+ }
+ }
+ res->int_neighs = obstack_finish(phase_obst(ph));
+ res->n_neighs = len;
}
return res;
}
/**
* Check if affinity chunk @p chunk interferes with node @p irn.
*/
-static INLINE int aff_chunk_interferes(co_mst_env_t *env, aff_chunk_t *chunk, ir_node *irn) {
- void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
- ir_node *neigh;
+static INLINE int aff_chunk_interferes(co_mst_env_t *env, const aff_chunk_t *chunk, ir_node *irn) {
+#if 1
+ if (bitset_is_set(chunk->interfere, get_irn_idx(irn)))
+ return 1;
+#else
+ const co_mst_irn_t *node = get_co_mst_irn(env, irn);
+ const ir_node *neigh;
+ int i;
- be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) {
+ 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;
}
-
+#endif
return 0;
}
* @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, aff_chunk_t *c1, aff_chunk_t *c2) {
+static INLINE int aff_chunks_interfere(co_mst_env_t *env, const aff_chunk_t *c1, const aff_chunk_t *c2) {
int idx;
+ bitset_t *tmp;
if (c1 == c2)
return 0;
-
+#if 1
+ tmp = bitset_alloca(get_irg_last_idx(env->co->irg));
+ tmp = bitset_copy(tmp, c1->interfere);
+ tmp = bitset_and(tmp, c2->nodes);
+ if (bitset_popcnt(tmp) > 0)
+ return 1;
+#else
/* 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;
}
-
+#endif
return 0;
}
/**
- * Let c1 absorb the nodes of c2 (only possible when there
- * are no interference edges from c1 to c2).
+ * Returns the affinity chunk of @p irn or creates a new
+ * one with @p irn as element if there is none assigned.
+ */
+static INLINE aff_chunk_t *get_aff_chunk(co_mst_env_t *env, ir_node *irn) {
+ co_mst_irn_t *node = get_co_mst_irn(env, irn);
+ return node->chunk;
+}
+
+/**
+ * Let chunk(src) absorb the nodes of chunk(tgt) (only possible when there
+ * are no interference edges from chunk(src) to chunk(tgt)).
* @return 1 if successful, 0 if not possible
*/
-static int aff_chunk_absorb(co_mst_env_t *env, aff_chunk_t *c1, aff_chunk_t *c2) {
- DB((env->dbg, LEVEL_4, "Attempt to let c1 (id %d): ", c1->id));
- DBG_AFF_CHUNK(env, LEVEL_4, c1);
- DB((env->dbg, LEVEL_4, "\n\tabsorb c2 (id %d): ", c2->id));
- DBG_AFF_CHUNK(env, LEVEL_4, c2);
- DB((env->dbg, LEVEL_4, "\n"));
-
- if (c1 != c2 && ! aff_chunks_interfere(env, c1, c2)) {
+static int aff_chunk_absorb(co_mst_env_t *env, ir_node *src, ir_node *tgt) {
+ aff_chunk_t *c1 = get_aff_chunk(env, src);
+ aff_chunk_t *c2 = get_aff_chunk(env, tgt);
+
+ DEBUG_ONLY(
+ DB((dbg, LEVEL_4, "Attempt to let c1 (id %d): ", c1 ? c1->id : -1));
+ 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));
+ if (c2) {
+ DBG_AFF_CHUNK(env, LEVEL_4, c2);
+ } else {
+ DB((dbg, LEVEL_4, "{%+F}", tgt));
+ }
+ DB((dbg, LEVEL_4, "\n"));
+ )
+
+ if (c1 == NULL) {
+ if (c2 == NULL) {
+ /* no chunk exists */
+ co_mst_irn_t *mirn = get_co_mst_irn(env, src);
+ int i;
+
+ for (i = mirn->n_neighs - 1; i >= 0; --i) {
+ if (mirn->int_neighs[i] == tgt)
+ break;
+ }
+ if (i < 0) {
+ /* create one containing both nodes */
+ c1 = new_aff_chunk(env);
+ aff_chunk_add_node(c1, get_co_mst_irn(env, src));
+ aff_chunk_add_node(c1, get_co_mst_irn(env, tgt));
+ goto absorbed;
+ }
+ } else {
+ /* c2 already exists */
+ if (! aff_chunk_interferes(env, 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)) {
+ aff_chunk_add_node(c1, get_co_mst_irn(env, tgt));
+ goto absorbed;
+ }
+ } else if (c1 != c2 && ! aff_chunks_interfere(env, c1, c2)) {
int idx;
bitset_or(c1->nodes, c2->nodes);
+ bitset_or(c1->interfere, c2->interfere);
c1->weight_consistent = 0;
bitset_foreach(c2->nodes, idx) {
mn->chunk = c1;
}
- DB((env->dbg, LEVEL_4, " ... absorbed, c2 deleted\n"));
delete_aff_chunk(env, c2);
- return 1;
+ goto absorbed;
}
- DB((env->dbg, LEVEL_4, " ... c1 interferes with c2, skipped\n"));
+ DB((dbg, LEVEL_4, " ... c1 interferes with c2, skipped\n"));
return 0;
-}
-/**
- * Returns the affinity chunk of @p irn or creates a new
- * one with @p irn as element if there is none assigned.
- */
-static INLINE aff_chunk_t *get_aff_chunk(co_mst_env_t *env, ir_node *irn) {
- co_mst_irn_t *node = get_co_mst_irn(env, irn);
- assert(node->chunk && "Node should have a chunk.");
- return node->chunk;
+absorbed:
+ DB((dbg, LEVEL_4, " ... absorbed\n"));
+ return 1;
}
/**
* Assures that the weight of the given chunk is consistent.
*/
-static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) {
+static void aff_chunk_assure_weight(const co_mst_env_t *env, aff_chunk_t *c) {
if (! c->weight_consistent) {
int w = 0;
int idx;
bitset_foreach(c->nodes, idx) {
- ir_node *n = get_idx_irn(env->co->irg, idx);
- affinity_node_t *an = get_affinity_info(env->co, n);
+ ir_node *n = get_idx_irn(env->co->irg, idx);
+ const affinity_node_t *an = get_affinity_info(env->co, n);
if (an != NULL) {
neighb_t *neigh;
co_gs_foreach_neighb(an, neigh) {
- ir_node *m = neigh->irn;
- 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))
}
/**
- * Count the number of interfering affinity neighbors
+ * Count the number of interfering affinity neighbours
*/
-static int count_interfering_aff_neighs(co_mst_env_t *env, affinity_node_t *an) {
- neighb_t *neigh;
- void *neigh_it = be_ifg_neighbours_iter_alloca(env->ifg);
- ir_node *irn = an->irn;
- int res = 0;
+static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an) {
+ const neighb_t *neigh;
+ ir_node *irn = an->irn;
+ const co_mst_irn_t *node = get_co_mst_irn(env, irn);
+ int res = 0;
co_gs_foreach_neighb(an, neigh) {
- ir_node *m, *n = neigh->irn;
+ const ir_node *n = neigh->irn;
+ int i;
/* skip ignore nodes */
if (arch_irn_is(env->aenv, n, ignore))
continue;
- /* check if the affinity neighbor interfere */
- be_ifg_foreach_neighbour(env->ifg, neigh_it, irn, m) {
- if (m == n) {
+ /* check if the affinity neighbour interfere */
+ for (i = 0; i < node->n_neighs; ++i) {
+ if (node->int_neighs[i] == n) {
++res;
break;
}
if (an != NULL) {
neighb_t *neigh;
- if (n1->int_neigh < 0)
- n1->int_neigh = count_interfering_aff_neighs(env, an);
+ if (n1->int_aff_neigh < 0)
+ n1->int_aff_neigh = count_interfering_aff_neighs(env, an);
co_gs_foreach_neighb(an, neigh) {
ir_node *m = neigh->irn;
int m_idx = get_irn_idx(m);
/* record the edge in only one direction */
if (n_idx < m_idx) {
co_mst_irn_t *n2;
- aff_edge_t edge;
+ aff_edge_t edge;
/* skip ignore nodes */
if (arch_irn_is(env->aenv, m, ignore))
edge.tgt = m;
n2 = get_co_mst_irn(env, m);
- if (n2->int_neigh < 0) {
+ if (n2->int_aff_neigh < 0) {
affinity_node_t *am = get_affinity_info(env->co, m);
- n2->int_neigh = count_interfering_aff_neighs(env, am);
+ n2->int_aff_neigh = count_interfering_aff_neighs(env, am);
}
- edge.weight = (double)neigh->costs / (double)(1 + n1->int_neigh + n2->int_neigh);
+ edge.weight = (double)neigh->costs / (double)(1 + n1->int_aff_neigh + n2->int_aff_neigh);
ARR_APP1(aff_edge_t, edges, edge);
}
}
len = ARR_LEN(edges);
qsort(edges, len, sizeof(edges[0]), cmp_aff_edge);
for (i = 0; i < len; ++i) {
- aff_chunk_t *c1 = get_aff_chunk(env, edges[i].src);
- aff_chunk_t *c2 = get_aff_chunk(env, edges[i].tgt);
+ DBG((dbg, LEVEL_1, "edge (%u,%u) %f\n", edges[i].src->node_idx, edges[i].tgt->node_idx, edges[i].weight));
- DBG((env->dbg, LEVEL_1, "edge (%u,%u) %f\n", edges[i].src->node_idx, edges[i].tgt->node_idx, edges[i].weight));
-
- (void)aff_chunk_absorb(env, c1, c2);
+ (void)aff_chunk_absorb(env, edges[i].src, edges[i].tgt);
}
/* now insert all chunks into a priority queue */
foreach_pset_new(&env->chunkset, curr_chunk, iter) {
aff_chunk_assure_weight(env, curr_chunk);
- DBG((env->dbg, LEVEL_1, "entry #%d", curr_chunk->id));
+ DBG((dbg, LEVEL_1, "entry #%d", curr_chunk->id));
DBG_AFF_CHUNK(env, LEVEL_1, curr_chunk);
- DBG((env->dbg, LEVEL_1, "\n"));
-
+ 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);
+
+ if (mirn->chunk == NULL) {
+ /* no chunk is allocated so far, do it now */
+ aff_chunk_t *curr_chunk = new_aff_chunk(env);
+ aff_chunk_add_node(curr_chunk, mirn);
+
+ aff_chunk_assure_weight(env, curr_chunk);
+
+ DBG((dbg, LEVEL_1, "entry #%d", 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);
+ }
+ }
DEL_ARR_F(edges);
}
{
waitq *nodes = new_waitq();
- DBG((env->dbg, LEVEL_1, "\nExpanding new chunk (id %d) from %+F:", chunk->id, node->irn));
+ DBG((dbg, LEVEL_1, "\nExpanding new chunk (id %d) from %+F:", chunk->id, node->irn));
/* init queue and chunk */
waitq_put(nodes, node);
bitset_set(visited, get_irn_idx(node->irn));
aff_chunk_add_node(chunk, node);
- DB((env->dbg, LEVEL_1, " %+F", node->irn));
+ DB((dbg, LEVEL_1, " %+F", node->irn));
/* as long as there are nodes in the queue */
while (! waitq_empty(nodes)) {
*/
bitset_set(visited, m_idx);
aff_chunk_add_node(chunk, n2);
- DB((env->dbg, LEVEL_1, " %+F", n2->irn));
+ DB((dbg, LEVEL_1, " %+F", n2->irn));
/* enqueue for further search */
waitq_put(nodes, n2);
}
}
}
- DB((env->dbg, LEVEL_1, "\n"));
+ DB((dbg, LEVEL_1, "\n"));
del_waitq(nodes);
}
* 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);
- void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
+ affinity_node_t *an = get_affinity_info(env->co, node->irn);
neighb_t *aff_neigh;
- ir_node *int_neigh;
- int idx;
+ int idx, i;
col_cost_init(env, costs, 0.0);
}
/* calculate (positive) costs for interfering neighbours */
- be_ifg_foreach_neighbour(env->ifg, nodes_it, node->irn, int_neigh) {
+ for (i = 0; i < node->n_neighs; ++i) {
co_mst_irn_t *neigh;
int col, col_cnt;
+ ir_node *int_neigh;
+
+ int_neigh = node->int_neighs[i];
/* skip ignore nodes */
if (arch_irn_is(env->aenv, int_neigh, ignore))
static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, waitq *changed_ones) {
int i;
waitq *local_changed = new_waitq();
- void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
+ waitq *tmp = new_waitq();
- DBG((env->dbg, LEVEL_1, "\tRecoloring %+F with color-costs", node->irn));
+ DBG((dbg, LEVEL_1, "\tRecoloring %+F with color-costs", node->irn));
DBG_COL_COST(env, LEVEL_1, costs);
- DB((env->dbg, LEVEL_1, "\n"));
+ DB((dbg, LEVEL_1, "\n"));
for (i = 0; i < env->n_regs; ++i) {
- int tgt_col = costs[i].col;
- int neigh_ok = 1;
- ir_node *neigh;
+ 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 == COL_COST_INFEASIBLE) {
node->tmp_fixed = 0;
del_waitq(local_changed);
+ del_waitq(tmp);
return 0;
}
waitq_put(local_changed, node);
/* try to color all interfering neighbours with current color forbidden */
- be_ifg_foreach_neighbour(env->ifg, nodes_it, node->irn, neigh) {
+ for (j = 0; j < node->n_neighs; ++j) {
co_mst_irn_t *nn;
+ ir_node *neigh;
+
+ neigh = node->int_neighs[j];
/* skip ignore nodes */
if (arch_irn_is(env->aenv, neigh, ignore))
we bail out and try the next color.
*/
if (get_mst_irn_col(nn) == tgt_col) {
- waitq *tmp = new_waitq();
-
/* 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));
- del_waitq(tmp);
if (! neigh_ok)
break;
while (! waitq_empty(local_changed))
waitq_put(changed_ones, waitq_get(local_changed));
del_waitq(local_changed);
+ del_waitq(tmp);
return 1;
}
else {
}
del_waitq(local_changed);
+ del_waitq(tmp);
return 0;
}
/* if node already has the target color -> good, temporary fix it */
if (col == tgt_col) {
- DBG((env->dbg, LEVEL_4, "\t\tCNC: %+F has already color %d, fix temporary\n", node->irn, 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;
col_cost_init_single(env, costs, tgt_col);
- DBG((env->dbg, LEVEL_4, "\t\tCNC: Attempt to recolor %+F ===>>\n", node->irn));
+ DBG((dbg, LEVEL_4, "\t\tCNC: Attempt to recolor %+F ===>>\n", node->irn));
res = recolor_nodes(env, node, costs, changed_ones);
- DBG((env->dbg, LEVEL_4, "\t\tCNC: <<=== Recoloring of %+F %s\n", node->irn, res ? "succeeded" : "failed"));
+ DBG((dbg, LEVEL_4, "\t\tCNC: <<=== Recoloring of %+F %s\n", node->irn, res ? "succeeded" : "failed"));
return res;
}
DEBUG_ONLY(
- if (firm_dbg_get_mask(env->dbg) & LEVEL_4) {
+ if (firm_dbg_get_mask(dbg) & LEVEL_4) {
if (node->fixed || node->tmp_fixed)
- DB((env->dbg, LEVEL_4, "\t\tCNC: %+F has already fixed color %d\n", node->irn, col));
+ DB((dbg, LEVEL_4, "\t\tCNC: %+F has already fixed color %d\n", node->irn, col));
else {
- DB((env->dbg, LEVEL_4, "\t\tCNC: color %d not admissible for %+F (", tgt_col, node->irn));
+ DB((dbg, LEVEL_4, "\t\tCNC: color %d not admissible for %+F (", tgt_col, node->irn));
dbg_admissible_colors(env, node);
- DB((env->dbg, LEVEL_4, ")\n"));
+ DB((dbg, LEVEL_4, ")\n"));
}
}
)
bitset_t *visited;
int col, idx;
- DB((env->dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
+ DB((dbg, LEVEL_2, "fragmentizing chunk #%d", c->id));
DBG_AFF_CHUNK(env, LEVEL_2, c);
- DB((env->dbg, LEVEL_2, "\n"));
+ DB((dbg, LEVEL_2, "\n"));
/* check which color is the "best" for the given chunk */
- for (col = 0; col < env->k; ++col) {
+ for (col = 0; col < env->n_regs; ++col) {
int one_good = 0;
aff_chunk_t *local_best;
- DB((env->dbg, LEVEL_3, "\ttrying color %d\n", col));
+ /* skip ignore colors */
+ if (bitset_is_set(env->ignore_regs, col))
+ continue;
+
+ DB((dbg, LEVEL_3, "\ttrying color %d\n", col));
/* try to bring all nodes of given chunk to the current color. */
bitset_foreach(c->nodes, idx) {
assert(! node->fixed && "Node must not have a fixed color.");
- DB((env->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, col));
one_good |= change_node_color(env, node, col, changed_ones);
- DB((env->dbg, LEVEL_4, "\t\t... %+F attempt from %d to %d %s\n", irn, node->col, col, one_good ? "succeeded" : "failed"));
+ 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 (local_best) {
aff_chunk_assure_weight(env, local_best);
- DB((env->dbg, LEVEL_4, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, 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 = col;
- DB((env->dbg, LEVEL_4, "\n\t\t... setting global best chunk (id %d), color %d\n", best_chunk->id, best_color));
+ DB((dbg, LEVEL_4, "\n\t\t... setting global best chunk (id %d), color %d\n", best_chunk->id, best_color));
} else {
- DB((env->dbg, LEVEL_4, "\n\t\t... omitting, global best is better\n"));
+ DB((dbg, LEVEL_4, "\n\t\t... omitting, global best is better\n"));
}
}
/* return if coloring failed */
if (! best_chunk) {
- delete_aff_chunk(env, c);
del_waitq(changed_ones);
return;
}
- DB((env->dbg, LEVEL_2, "\tbest chunk #%d ", best_chunk->id));
+ DB((dbg, LEVEL_2, "\tbest chunk #%d ", best_chunk->id));
DBG_AFF_CHUNK(env, LEVEL_2, best_chunk);
- DB((env->dbg, LEVEL_2, "using color %d\n", best_color));
+ 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) {
int res;
res = change_node_color(env, node, best_color, changed_ones);
- assert(res && "color manifesting failed");
+ if (! res)
+ panic("Color manifesting failed for %+F, color %d in chunk %d\n", irn, best_color, best_chunk->id);
node->fixed = 1;
node->chunk = best_chunk;
}
/**
* 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;
k = be_put_ignore_regs(co->cenv->birg, co->cls, ignore_regs);
k = n_regs - k;
- FIRM_DBG_REGISTER(mst_env.dbg, "firm.be.co.heur4");
mst_env.n_regs = n_regs;
mst_env.k = k;
mst_env.chunks = new_pqueue();
mst_env.aenv = co->aenv;
pset_new_init(&mst_env.chunkset);
- DBG((mst_env.dbg, LEVEL_1, "==== Coloring %+F, class %s ====\n", co->irg, co->cls->name));
+ DBG((dbg, LEVEL_1, "==== Coloring %+F, class %s ====\n", co->irg, co->cls->name));
/* build affinity chunks */
build_affinity_chunks(&mst_env);
aff_chunk_t *chunk = pqueue_get(mst_env.chunks);
color_aff_chunk(&mst_env, chunk);
- DB((mst_env.dbg, LEVEL_4, "<<<====== Coloring chunk (%d) done\n", chunk->id));
+ DB((dbg, LEVEL_4, "<<<====== Coloring chunk (%d) done\n", chunk->id));
delete_aff_chunk(&mst_env, chunk);
}
reg = arch_register_for_index(co->cls, mirn->col);
arch_set_irn_register(co->aenv, irn, reg);
- DB((mst_env.dbg, LEVEL_1, "%+F set color from %d to %d\n", irn, mirn->init_col, mirn->col));
+ DB((dbg, LEVEL_1, "%+F set color from %d to %d\n", irn, mirn->init_col, mirn->col));
}
/* free allocated memory */
return 0;
}
+
+void be_init_copyheur4(void) {
+ FIRM_DBG_REGISTER(dbg, "firm.be.co.heur4");
+}
+
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4);
projects / libfirm / blobdiff