#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)
+#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;
/**
* Write a chunk to stderr for debugging.
*/
-static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c) {
+static void dbg_aff_chunk(const co_mst_env_t *env, const aff_chunk_t *c)
+{
int i, l;
(void) env;
if (c->weight_consistent)
/**
* Dump all admissible colors to stderr.
*/
-static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node) {
- bitset_pos_t idx;
+static void dbg_admissible_colors(const co_mst_env_t *env, const co_mst_irn_t *node)
+{
+ unsigned idx;
(void) env;
- if (bitset_popcnt(node->adm_colors) < 1)
+ if (bitset_popcount(node->adm_colors) < 1)
fprintf(stderr, "no admissible colors?!?");
else {
bitset_foreach(node->adm_colors, idx) {
/**
* Dump color-cost pairs to stderr.
*/
-static void dbg_col_cost(const co_mst_env_t *env, const col_cost_t *cost) {
+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)
fprintf(stderr, " (%d, %.4f)", cost[i].col, cost[i].cost);
#endif /* DEBUG_libfirm */
-static inline int get_mst_irn_col(const co_mst_irn_t *node) {
+static inline int get_mst_irn_col(const co_mst_irn_t *node)
+{
return node->tmp_col >= 0 ? node->tmp_col : node->col;
}
/**
* @return 1 if node @p node has color @p col, 0 otherwise.
*/
-static int decider_has_color(const 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(const 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(const co_mst_irn_t *node, int col) {
+static int decider_always_yes(const co_mst_irn_t *node, int col)
+{
(void) node;
(void) col;
return 1;
}
/** compares two affinity edges by its weight */
-static int cmp_aff_edge(const void *a, const void *b) {
+static int cmp_aff_edge(const void *a, const void *b)
+{
const aff_edge_t *e1 = a;
const aff_edge_t *e2 = b;
}
/** compares to color-cost pairs */
-static __attribute__((unused)) int cmp_col_cost_lt(const void *a, const void *b) {
+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;
real_t diff = c1->cost - c2->cost;
return (diff > 0) - (diff < 0);
}
-static int cmp_col_cost_gt(const void *a, const void *b) {
+static int cmp_col_cost_gt(const void *a, const void *b)
+{
const col_cost_t *c1 = a;
const col_cost_t *c2 = b;
real_t diff = c2->cost - c1->cost;
/**
* Creates a new affinity chunk
*/
-static inline aff_chunk_t *new_aff_chunk(co_mst_env_t *env) {
+static inline aff_chunk_t *new_aff_chunk(co_mst_env_t *env)
+{
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);
/**
* Frees all memory allocated by an affinity chunk.
*/
-static inline void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
+static inline void delete_aff_chunk(co_mst_env_t *env, aff_chunk_t *c)
+{
pset_remove(env->chunkset, c, c->id);
DEL_ARR_F(c->interfere);
DEL_ARR_F(c->n);
* @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) {
+static inline int nodes_bsearch(const ir_node **arr, const ir_node *n)
+{
int hi = ARR_LEN(arr);
int lo = 0;
}
/** Check if a node n can be found inside arr. */
-static int node_contains(const ir_node **arr, const ir_node *n) {
+static int node_contains(const ir_node **arr, const ir_node *n)
+{
int i = nodes_bsearch(arr, n);
return i >= 0;
}
*
* @return 1 if the node was inserted, 0 else
*/
-static int nodes_insert(const ir_node ***arr, const ir_node *irn) {
+static int nodes_insert(const ir_node ***arr, const ir_node *irn)
+{
int idx = nodes_bsearch(*arr, irn);
if (idx < 0) {
/**
* Adds a node to an affinity chunk
*/
-static inline void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node) {
+static inline void aff_chunk_add_node(aff_chunk_t *c, co_mst_irn_t *node)
+{
int i;
if (! nodes_insert(&c->n, node->irn))
/**
* In case there is no phase information for irn, initialize it.
*/
-static void *co_mst_irn_init(ir_phase *ph, const ir_node *irn, void *old) {
+static void *co_mst_irn_init(ir_phase *ph, const ir_node *irn, void *old)
+{
co_mst_irn_t *res = old ? old : phase_alloc(ph, sizeof(res[0]));
co_mst_env_t *env = ph->priv;
bitset_andnot(res->adm_colors, env->ignore_regs);
/* compute the constraint factor */
- res->constr_factor = (real_t) (1 + env->n_regs - bitset_popcnt(res->adm_colors)) / env->n_regs;
+ res->constr_factor = (real_t) (1 + env->n_regs - bitset_popcount(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(neigh, ignore)) {
+ if (!arch_irn_is_ignore(neigh)) {
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(const aff_chunk_t *chunk, const ir_node *irn) {
+static inline int aff_chunk_interferes(const aff_chunk_t *chunk, const ir_node *irn)
+{
return node_contains(chunk->interfere, irn);
}
* @param c2 Another chunk
* @return 1 if there are interferences between nodes of c1 and c2, 0 otherwise.
*/
-static inline int aff_chunks_interfere(const aff_chunk_t *c1, const aff_chunk_t *c2) {
+static inline int aff_chunks_interfere(const aff_chunk_t *c1, const aff_chunk_t *c2)
+{
int i;
if (c1 == 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, const ir_node *irn) {
+static inline aff_chunk_t *get_aff_chunk(co_mst_env_t *env, const ir_node *irn)
+{
co_mst_irn_t *node = get_co_mst_irn(env, irn);
return node->chunk;
}
* 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, const ir_node *src, const ir_node *tgt) {
+static int aff_chunk_absorb(co_mst_env_t *env, const ir_node *src, const ir_node *tgt)
+{
aff_chunk_t *c1 = get_aff_chunk(env, src);
aff_chunk_t *c2 = get_aff_chunk(env, tgt);
/**
* 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(co_mst_env_t *env, aff_chunk_t *c)
+{
if (! c->weight_consistent) {
int w = 0;
int idx, len, i;
node->chunk = c;
if (node->constr_factor > REAL(0.0)) {
- bitset_pos_t col;
+ unsigned 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 ir_node *m = neigh->irn;
- /* skip ignore nodes */
- if (arch_irn_is(m, ignore))
+ if (arch_irn_is_ignore(m))
continue;
w += node_contains(c->n, m) ? neigh->costs : 0;
c->color_affinity[i].cost *= (REAL(1.0) / ARR_LEN(c->n));
c->weight = w;
- // c->weight = bitset_popcnt(c->nodes);
+ // c->weight = bitset_popcount(c->nodes);
c->weight_consistent = 1;
}
}
/**
* Count the number of interfering affinity neighbours
*/
-static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an) {
+static int count_interfering_aff_neighs(co_mst_env_t *env, const affinity_node_t *an)
+{
const neighb_t *neigh;
const ir_node *irn = an->irn;
const co_mst_irn_t *node = get_co_mst_irn(env, irn);
const ir_node *n = neigh->irn;
int i;
- /* skip ignore nodes */
- if (arch_irn_is(n, ignore))
+ if (arch_irn_is_ignore(n))
continue;
/* check if the affinity neighbour interfere */
* merged if there are no interference edges from one
* chunk to the other.
*/
-static void build_affinity_chunks(co_mst_env_t *env) {
+static void build_affinity_chunks(co_mst_env_t *env)
+{
void *nodes_it = be_ifg_nodes_iter_alloca(env->ifg);
aff_edge_t *edges = NEW_ARR_F(aff_edge_t, 0);
ir_node *n;
co_mst_irn_t *n1;
affinity_node_t *an;
- /* skip ignore nodes */
- if (arch_irn_is(n, ignore))
+ if (arch_irn_is_ignore(n))
continue;
n1 = get_co_mst_irn(env, n);
aff_edge_t edge;
/* skip ignore nodes */
- if (arch_irn_is(m, ignore))
+ if (arch_irn_is_ignore(m))
continue;
edge.src = n;
int w = 0;
neighb_t *neigh;
- if (arch_irn_is(irn, ignore))
+ if (arch_irn_is_ignore(irn))
continue;
if (an) {
while (!pqueue_empty(grow)) {
ir_node *irn = pqueue_pop_front(grow);
affinity_node_t *an = get_affinity_info(env->co, irn);
- neighb_t *neigh;
+ neighb_t *neigh;
- if (arch_irn_is(irn, ignore))
+ if (arch_irn_is_ignore(irn))
continue;
assert(i <= ARR_LEN(chunk->n));
int m_idx = get_irn_idx(m);
co_mst_irn_t *n2;
- /* skip ignore nodes */
- if (arch_irn_is(m, ignore))
+ if (arch_irn_is_ignore(m))
continue;
n2 = get_co_mst_irn(env, m);
/**
* Fragment the given chunk into chunks having given color and not having given color.
*/
-static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, waitq *tmp) {
+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, len;
aff_chunk_t *best = NULL;
* 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(struct list_head *nodes) {
+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, "\n"));
}
-static inline void materialize_coloring(struct list_head *nodes) {
+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);
/**
* 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) {
- int *neigh_cols = alloca(env->n_regs * sizeof(*neigh_cols));
- int n_loose = 0;
+static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs)
+{
+ int *neigh_cols = ALLOCAN(int, env->n_regs);
+ int n_loose = 0;
real_t coeff;
- int i;
+ int i;
for (i = 0; i < env->n_regs; ++i) {
neigh_cols[i] = 0;
* 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, struct list_head *changed, int depth, int *max_depth, int *trip) {
+static int change_node_color_excluded(co_mst_env_t *env, co_mst_irn_t *node, int exclude_col, struct list_head *changed, int depth, int *max_depth, int *trip)
+{
int col = get_mst_irn_col(node);
int res = 0;
/* The node has the color it should not have _and_ has not been visited yet. */
if (is_loose(node)) {
- col_cost_t *costs = alloca(env->n_regs * sizeof(costs[0]));
+ col_cost_t *costs = ALLOCAN(col_cost_t, env->n_regs);
/* Get the costs for giving the node a specific color. */
determine_color_costs(env, node, costs);
* 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, struct list_head *changed, int depth, int *max_depth, int *trip) {
+static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *costs, struct list_head *changed, int depth, int *max_depth, int *trip)
+{
int i;
struct list_head local_changed;
neigh = node->int_neighs[j];
- /* skip ignore nodes */
- if (arch_irn_is(neigh, ignore))
+ if (arch_irn_is_ignore(neigh))
continue;
nn = get_co_mst_irn(env, neigh);
* 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, struct list_head *changed) {
+static int change_node_color(co_mst_env_t *env, co_mst_irn_t *node, int tgt_col, struct list_head *changed)
+{
int col = get_mst_irn_col(node);
/* if node already has the target color -> good, temporary fix it */
* Tries to color an affinity chunk (or at least a part of it).
* Inserts uncolored parts of the chunk as a new chunk into the priority queue.
*/
-static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) {
+static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c)
+{
aff_chunk_t *best_chunk = NULL;
int n_nodes = ARR_LEN(c->n);
int best_color = -1;
int n_int_chunks = 0;
waitq *tmp_chunks = new_waitq();
waitq *best_starts = NULL;
- col_cost_t *order = alloca(env->n_regs * sizeof(order[0]));
+ col_cost_t *order = ALLOCANZ(col_cost_t, env->n_regs);
bitset_t *visited;
int idx, len, i, nidx, pos;
struct list_head changed;
++env->chunk_visited;
/* compute color preference */
- memset(order, 0, env->n_regs * sizeof(order[0]));
-
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);
/**
* Main driver for mst safe coalescing algorithm.
*/
-int co_solve_heuristic_mst(copy_opt_t *co) {
+static 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 i, j, k;
stat_ev_tim_push();
/* init phase */
- phase_init(&mst_env.ph, "co_mst", co->irg, PHASE_DEFAULT_GROWTH, co_mst_irn_init, &mst_env);
+ phase_init(&mst_env.ph, co->irg, co_mst_irn_init);
+ phase_set_private(&mst_env.ph, &mst_env);
k = be_put_ignore_regs(co->cenv->birg, co->cls, ignore_regs);
k = n_regs - k;
/* apply coloring */
foreach_phase_irn(&mst_env.ph, irn) {
- co_mst_irn_t *mirn;
+ co_mst_irn_t *mirn;
const arch_register_t *reg;
- if (arch_irn_is(irn, ignore))
+ if (arch_irn_is_ignore(irn))
continue;
mirn = get_co_mst_irn(&mst_env, irn);
/* free allocated memory */
del_pqueue(mst_env.chunks);
- phase_free(&mst_env.ph);
+ phase_deinit(&mst_env.ph);
del_pset(mst_env.chunkset);
stat_ev_tim_pop("heur4_total");
LC_OPT_LAST
};
-
-void be_init_copyheur4(void) {
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4);
+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");
+ static co_algo_info copyheur = {
+ co_solve_heuristic_mst, 0
+ };
+
lc_opt_add_table(heur4_grp, options);
+ be_register_copyopt("heur4", ©heur);
+
FIRM_DBG_REGISTER(dbg, "firm.be.co.heur4");
}
-
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_copyheur4);
projects / libfirm / blobdiff