X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbecopyheur4.c;h=91243cc578db6e8fbac5a4fd70f36443648f4c7f;hb=b88d0e6fd2154f51a2a333285c759f6757c4c715;hp=c9a8bb7a0d54bc268f28d1fd9d78fffabb7eab98;hpb=49aac8d3a962a11fa648a2d8cd35d607c28e308b;p=libfirm diff --git a/ir/be/becopyheur4.c b/ir/be/becopyheur4.c index c9a8bb7a0..91243cc57 100644 --- a/ir/be/becopyheur4.c +++ b/ir/be/becopyheur4.c @@ -81,8 +81,8 @@ static firm_dbg_module_t *dbg = NULL; typedef float real_t; #define REAL(C) (C ## f) -static int last_chunk_id = 0; -static int recolor_limit = 4; +static unsigned last_chunk_id = 0; +static int recolor_limit = 7; static real_t dislike_influence = REAL(0.1); typedef struct _col_cost_t { @@ -95,12 +95,12 @@ typedef struct _col_cost_t { */ typedef struct _aff_chunk_t { const ir_node **n; /**< An ARR_F containing all nodes of the chunk. */ - const ir_node **interfere; /**< An ARR_F containing all inference. */ + 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; + unsigned id; /**< An id of this chunk. */ + unsigned visited; col_cost_t color_affinity[1]; } aff_chunk_t; @@ -110,7 +110,7 @@ typedef struct _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 */ @@ -124,7 +124,7 @@ typedef struct _co_mst_env_t { 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; @@ -155,6 +155,7 @@ typedef int decide_func_t(const co_mst_irn_t *node, int col); */ 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) ir_fprintf(stderr, " $%d ", c->weight); ir_fprintf(stderr, "{"); @@ -255,7 +256,7 @@ static int cmp_col_cost_gt(const void *a, const void *b) { static INLINE aff_chunk_t *new_aff_chunk(co_mst_env_t *env) { aff_chunk_t *c = xmalloc(sizeof(*c) + (env->n_regs - 1) * sizeof(c->color_affinity[0])); c->n = NEW_ARR_F(const ir_node *, 0); - c->interfere = NEW_ARR_F(ir_node *, 0); + c->interfere = NEW_ARR_F(const ir_node *, 0); c->weight = -1; c->weight_consistent = 0; c->deleted = 0; @@ -455,13 +456,13 @@ static int aff_chunk_absorb(co_mst_env_t *env, const ir_node *src, const ir_node 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 { @@ -553,7 +554,6 @@ static void aff_chunk_assure_weight(co_mst_env_t *env, aff_chunk_t *c) { 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)) @@ -681,7 +681,7 @@ static void build_affinity_chunks(co_mst_env_t *env) { 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")); @@ -698,7 +698,7 @@ static void build_affinity_chunks(co_mst_env_t *env) { 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")); @@ -782,7 +782,7 @@ static void expand_chunk_from(co_mst_env_t *env, co_mst_irn_t *node, bitset_t *v { 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); @@ -862,12 +862,12 @@ static aff_chunk_t *fragment_chunk(co_mst_env_t *env, int col, aff_chunk_t *c, w 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 */ @@ -1013,21 +1013,25 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost 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 == REAL(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."); @@ -1080,6 +1084,7 @@ static int recolor_nodes(co_mst_env_t *env, co_mst_irn_t *node, col_cost_t *cost } } + DBG((dbg, LEVEL_4, "\tAll colors failed\n")); return 0; } @@ -1150,11 +1155,11 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { int idx, len, i, nidx, pos; struct list_head changed; - 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; @@ -1258,7 +1263,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { 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) { @@ -1267,7 +1272,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { 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); @@ -1299,7 +1304,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { 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)); @@ -1309,7 +1314,7 @@ static void color_aff_chunk(co_mst_env_t *env, aff_chunk_t *c) { 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); @@ -1390,6 +1395,8 @@ int co_solve_heuristic_mst(copy_opt_t *co) { ir_node *irn; co_mst_env_t mst_env; + last_chunk_id = 0; + stat_ev_tim_push(); /* init phase */ @@ -1434,7 +1441,7 @@ int co_solve_heuristic_mst(copy_opt_t *co) { aff_chunk_t *chunk = pqueue_get(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); }