X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur4.c;h=21d54436c05283b834ccbe9d3a1225d71dd5b0e7;hb=9276447aec4972df060349e162f583c4898dfec8;hp=5e689195a05eeb398a0b7a8607a8074cfb907cc9;hpb=e21c22cd854457b5732ffea622ed461dc0fbec8e;p=libfirm diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c index 5e689195a..21d54436c 100644 --- a/ir/be/becopyheur4.c +++ b/ir/be/becopyheur4.c @@ -59,8 +59,8 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;) #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(dbg) & (level)) dbg_aff_chunk((env), (chunk));) -#define DBG_COL_COST(env, level, cost) DEBUG_ONLY(if (firm_dbg_get_mask(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; @@ -69,24 +69,31 @@ typedef struct _col_cost_t { 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. */ + 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 */ 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 */ @@ -100,7 +107,8 @@ 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; /**< ARR_D of all interfering neighbours (cached for speed reasons) */ + 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 */ @@ -111,14 +119,14 @@ typedef struct _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); @@ -133,7 +141,7 @@ static void dbg_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { /** * Dump all admissible colors to stderr. */ -static void dbg_admissible_colors(co_mst_env_t *env, co_mst_irn_t *node) { +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?!?"); @@ -146,7 +154,7 @@ static void dbg_admissible_colors(co_mst_env_t *env, co_mst_irn_t *node) { /** * Dump color-cost pairs to stderr. */ -static void dbg_col_cost(co_mst_env_t *env, 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) { if (cost[i].cost == COL_COST_INFEASIBLE) @@ -158,32 +166,32 @@ static void dbg_col_cost(co_mst_env_t *env, col_cost_t *cost) { #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; @@ -198,7 +206,7 @@ static int cmp_aff_edge(const void *a, const void *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; @@ -251,7 +259,7 @@ static void *co_mst_irn_init(ir_phase *ph, ir_node *irn, void *old) { unsigned len; res->irn = irn; - res->chunk = new_aff_chunk(env); + res->chunk = NULL; res->fixed = 0; res->tmp_fixed = 0; res->tmp_col = -1; @@ -260,10 +268,7 @@ static void *co_mst_irn_init(ir_phase *ph, ir_node *irn, void *old) { 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((dbg, LEVEL_4, "Creating phase info for %+F, chunk %d\n", irn, res->chunk->id)); + 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); @@ -283,13 +288,12 @@ static void *co_mst_irn_init(ir_phase *ph, ir_node *irn, void *old) { /* build list of interfering neighbours */ len = 0; - /* count them first as an obstack array cannot be extended */ - be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) - len++; - res->int_neighs = NEW_ARR_D(ir_node *, phase_obst(ph), len); - len = 0; - be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) - res->int_neighs[len++] = neigh; + be_ifg_foreach_neighbour(env->ifg, nodes_it, irn, neigh) { + obstack_ptr_grow(phase_obst(ph), neigh); + ++len; + } + res->int_neighs = obstack_finish(phase_obst(ph)); + res->n_neighs = len; } return res; } @@ -297,12 +301,12 @@ static void *co_mst_irn_init(ir_phase *ph, ir_node *irn, void *old) { /** * 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) { - co_mst_irn_t *node = get_co_mst_irn(env, irn); - ir_node *neigh; - int i; +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 < ARR_LEN(node->int_neighs); ++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; @@ -318,7 +322,7 @@ static INLINE int aff_chunk_interferes(co_mst_env_t *env, aff_chunk_t *chunk, ir * @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; if (c1 == c2) @@ -336,18 +340,70 @@ static INLINE int aff_chunks_interfere(co_mst_env_t *env, aff_chunk_t *c1, aff_c } /** - * 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((dbg, LEVEL_4, "Attempt to let c1 (id %d): ", c1->id)); - DBG_AFF_CHUNK(env, LEVEL_4, c1); - DB((dbg, LEVEL_4, "\n\tabsorb c2 (id %d): ", c2->id)); - DBG_AFF_CHUNK(env, LEVEL_4, c2); - DB((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); @@ -359,41 +415,34 @@ static int aff_chunk_absorb(co_mst_env_t *env, aff_chunk_t *c1, aff_chunk_t *c2) mn->chunk = c1; } - DB((dbg, LEVEL_4, " ... absorbed, c2 deleted\n")); delete_aff_chunk(env, c2); - return 1; + goto absorbed; } 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)) @@ -412,22 +461,22 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) { /** * 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; - ir_node *irn = an->irn; - co_mst_irn_t *node = get_co_mst_irn(env, 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 *n = neigh->irn; - int i; + const ir_node *n = neigh->irn; + int i; /* skip ignore nodes */ if (arch_irn_is(env->aenv, n, ignore)) continue; /* check if the affinity neighbour interfere */ - for (i = 0; i < ARR_LEN(node->int_neighs); ++i) { + for (i = 0; i < node->n_neighs; ++i) { if (node->int_neighs[i] == n) { ++res; break; @@ -503,12 +552,9 @@ static void build_affinity_chunks(co_mst_env_t *env) { 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)); - (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 */ @@ -519,9 +565,25 @@ static void build_affinity_chunks(co_mst_env_t *env) { 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); + + 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); } @@ -709,7 +771,7 @@ static void determine_color_costs(co_mst_env_t *env, co_mst_irn_t *node, col_cos } /* calculate (positive) costs for interfering neighbours */ - for (i = 0; i < ARR_LEN(node->int_neighs); ++i) { + for (i = 0; i < node->n_neighs; ++i) { co_mst_irn_t *neigh; int col, col_cnt; ir_node *int_neigh; @@ -821,7 +883,7 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost waitq_put(local_changed, node); /* try to color all interfering neighbours with current color forbidden */ - for (j = 0; j < ARR_LEN(node->int_neighs); ++j) { + for (j = 0; j < node->n_neighs; ++j) { co_mst_irn_t *nn; ir_node *neigh; @@ -944,10 +1006,11 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { /* 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; aff_chunk_t *local_best; - DB((dbg, LEVEL_3, "\ttrying color %d\n", col)); + DB((dbg, LEVEL_3, "\ttrying color %d\n", reg_col)); /* try to bring all nodes of given chunk to the current color. */ bitset_foreach(c->nodes, idx) { @@ -956,9 +1019,9 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { 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)); - one_good |= change_node_color(env, node, col, changed_ones); - DB((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\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")); } /* try next color when failed */ @@ -966,19 +1029,19 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { continue; /* fragment the chunk according to the coloring */ - local_best = fragment_chunk(env, col, c, tmp_chunks); + local_best = fragment_chunk(env, reg_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, col)); + DB((dbg, LEVEL_4, "\t\tlocal best chunk (id %d) for color %d: ", local_best->id, reg_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; + best_color = reg_col; 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")); @@ -1064,7 +1127,7 @@ 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; + unsigned k, idx, num; ir_node *irn; co_mst_env_t mst_env; @@ -1074,6 +1137,16 @@ int co_solve_heuristic_mst(copy_opt_t *co) 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(); @@ -1124,8 +1197,7 @@ int co_solve_heuristic_mst(copy_opt_t *co) return 0; } -void be_init_copyheur4(void) -{ +void be_init_copyheur4(void) { FIRM_DBG_REGISTER(dbg, "firm.be.co.heur4"); }